tei/MapLibreParticleLab
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use std::optional instead of mbgl::optional (#911)

Browse Source
This commit is contained in:
Bart Louwers
2023-03-17 12:51:59 +01:00
committed by GitHub
parent 36846439c6
commit 15ad65dd3d
482 changed files with 2605 additions and 2652 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@@ -281,7 +281,6 @@ target_sources(
${PROJECT_SOURCE_DIR}/include/mbgl/util/interpolate.hpp ${PROJECT_SOURCE_DIR}/include/mbgl/util/interpolate.hpp
${PROJECT_SOURCE_DIR}/include/mbgl/util/logging.hpp ${PROJECT_SOURCE_DIR}/include/mbgl/util/logging.hpp
${PROJECT_SOURCE_DIR}/include/mbgl/util/noncopyable.hpp ${PROJECT_SOURCE_DIR}/include/mbgl/util/noncopyable.hpp
${PROJECT_SOURCE_DIR}/include/mbgl/util/optional.hpp
${PROJECT_SOURCE_DIR}/include/mbgl/util/pass_types.hpp ${PROJECT_SOURCE_DIR}/include/mbgl/util/pass_types.hpp
${PROJECT_SOURCE_DIR}/include/mbgl/util/platform.hpp ${PROJECT_SOURCE_DIR}/include/mbgl/util/platform.hpp
${PROJECT_SOURCE_DIR}/include/mbgl/util/premultiply.hpp ${PROJECT_SOURCE_DIR}/include/mbgl/util/premultiply.hpp

5
benchmark/api/render.benchmark.cpp
View File

@@ -16,6 +16,7 @@
#include <mbgl/util/run_loop.hpp> #include <mbgl/util/run_loop.hpp>
#include <sstream> #include <sstream>
#include <optional>
using namespace mbgl; using namespace mbgl;
@@ -34,7 +35,7 @@ public:
util::RunLoop loop; util::RunLoop loop;
}; };
void prepare(Map& map, optional<std::string> json = nullopt) { void prepare(Map& map, std::optional<std::string> json = std::nullopt) {
map.getStyle().loadJSON(json ? *json : util::read_file("benchmark/fixtures/api/style.json")); map.getStyle().loadJSON(json ? *json : util::read_file("benchmark/fixtures/api/style.json"));
map.jumpTo(CameraOptions().withCenter(LatLng { 40.726989, -73.992857 }).withZoom(15.0)); // Manhattan map.jumpTo(CameraOptions().withCenter(LatLng { 40.726989, -73.992857 }).withZoom(15.0)); // Manhattan
@@ -42,7 +43,7 @@ void prepare(Map& map, optional<std::string> json = nullopt) {
map.getStyle().addImage(std::make_unique<style::Image>("test-icon", std::move(image), 1.0f)); map.getStyle().addImage(std::make_unique<style::Image>("test-icon", std::move(image), 1.0f));
} }
void prepare_map2(Map& map, optional<std::string> json = nullopt) { void prepare_map2(Map& map, std::optional<std::string> json = std::nullopt) {
map.getStyle().loadJSON(json ? *json : util::read_file("benchmark/fixtures/api/style.json")); map.getStyle().loadJSON(json ? *json : util::read_file("benchmark/fixtures/api/style.json"));
map.jumpTo(CameraOptions().withCenter(LatLng{41.379800, 2.176810}).withZoom(15.0)); // Barcelona map.jumpTo(CameraOptions().withCenter(LatLng{41.379800, 2.176810}).withZoom(15.0)); // Barcelona

4
benchmark/function/camera_function.benchmark.cpp
View File

@@ -27,7 +27,7 @@ static void Parse_CameraFunction(benchmark::State& state) {
state.PauseTiming(); state.PauseTiming();
auto doc = createFunctionJSON(stopCount); auto doc = createFunctionJSON(stopCount);
state.ResumeTiming(); state.ResumeTiming();
optional<PropertyValue<float>> result = conversion::convertJSON<PropertyValue<float>>(doc, error, false, false); std::optional<PropertyValue<float>> result = conversion::convertJSON<PropertyValue<float>>(doc, error, false, false);
if (!result) { if (!result) {
state.SkipWithError(error.message.c_str()); state.SkipWithError(error.message.c_str());
} }
@@ -39,7 +39,7 @@ static void Evaluate_CameraFunction(benchmark::State& state) {
size_t stopCount = state.range(0); size_t stopCount = state.range(0);
auto doc = createFunctionJSON(stopCount); auto doc = createFunctionJSON(stopCount);
conversion::Error error; conversion::Error error;
optional<PropertyValue<float>> function = conversion::convertJSON<PropertyValue<float>>(doc, error, false, false); std::optional<PropertyValue<float>> function = conversion::convertJSON<PropertyValue<float>>(doc, error, false, false);
if (!function) { if (!function) {
state.SkipWithError(error.message.c_str()); state.SkipWithError(error.message.c_str());
} }

4
benchmark/function/composite_function.benchmark.cpp
View File

@@ -33,7 +33,7 @@ static void Parse_CompositeFunction(benchmark::State& state) {
state.PauseTiming(); state.PauseTiming();
auto doc = createFunctionJSON(stopCount); auto doc = createFunctionJSON(stopCount);
state.ResumeTiming(); state.ResumeTiming();
optional<PropertyValue<float>> result = conversion::convertJSON<PropertyValue<float>>(doc, error, true, false); std::optional<PropertyValue<float>> result = conversion::convertJSON<PropertyValue<float>>(doc, error, true, false);
if (!result) { if (!result) {
state.SkipWithError(error.message.c_str()); state.SkipWithError(error.message.c_str());
} }
@@ -45,7 +45,7 @@ static void Evaluate_CompositeFunction(benchmark::State& state) {
size_t stopCount = state.range(0); size_t stopCount = state.range(0);
auto doc = createFunctionJSON(stopCount); auto doc = createFunctionJSON(stopCount);
conversion::Error error; conversion::Error error;
optional<PropertyValue<float>> function = conversion::convertJSON<PropertyValue<float>>(doc, error, true, false); std::optional<PropertyValue<float>> function = conversion::convertJSON<PropertyValue<float>>(doc, error, true, false);
if (!function) { if (!function) {
state.SkipWithError(error.message.c_str()); state.SkipWithError(error.message.c_str());
} }

4
benchmark/function/source_function.benchmark.cpp
View File

@@ -28,7 +28,7 @@ static void Parse_SourceFunction(benchmark::State& state) {
state.PauseTiming(); state.PauseTiming();
auto doc = createFunctionJSON(stopCount); auto doc = createFunctionJSON(stopCount);
state.ResumeTiming(); state.ResumeTiming();
optional<PropertyValue<float>> result = conversion::convertJSON<PropertyValue<float>>(doc, error, true, false); std::optional<PropertyValue<float>> result = conversion::convertJSON<PropertyValue<float>>(doc, error, true, false);
if (!result) { if (!result) {
state.SkipWithError(error.message.c_str()); state.SkipWithError(error.message.c_str());
} }
@@ -40,7 +40,7 @@ static void Evaluate_SourceFunction(benchmark::State& state) {
size_t stopCount = state.range(0); size_t stopCount = state.range(0);
auto doc = createFunctionJSON(stopCount); auto doc = createFunctionJSON(stopCount);
conversion::Error error; conversion::Error error;
optional<PropertyValue<float>> function = conversion::convertJSON<PropertyValue<float>>(doc, error, true, false); std::optional<PropertyValue<float>> function = conversion::convertJSON<PropertyValue<float>>(doc, error, true, false);
if (!function) { if (!function) {
state.SkipWithError(error.message.c_str()); state.SkipWithError(error.message.c_str());
} }

4
benchmark/src/mbgl/benchmark/stub_geometry_tile_feature.hpp
View File

@@ -31,8 +31,8 @@ public:
return id; return id;
} }
optional<Value> getValue(const std::string& key) const override { std::optional<Value> getValue(const std::string& key) const override {
return properties.count(key) ? properties.at(key) : optional<Value>(); return properties.count(key) ? properties.at(key) : std::optional<Value>();
} }
const GeometryCollection& getGeometries() const override { const GeometryCollection& getGeometries() const override {

4
benchmark/storage/offline_database.benchmark.cpp
View File

@@ -127,7 +127,7 @@ BENCHMARK_F(OfflineDatabase, GetTile)(benchmark::State& state) {
while (state.KeepRunning()) { while (state.KeepRunning()) {
auto res = db.get(Resource::tile("mapbox://tile_ambient" + util::toString(dis(gen)), 1, 0, 0, 0, Tileset::Scheme::XYZ)); auto res = db.get(Resource::tile("mapbox://tile_ambient" + util::toString(dis(gen)), 1, 0, 0, 0, Tileset::Scheme::XYZ));
assert(res != nullopt); assert(res != std::nullopt);
} }
} }
@@ -177,7 +177,7 @@ BENCHMARK_F(OfflineDatabase, GetTileFromDisabledDatabase)(benchmark::State& stat
while (state.KeepRunning()) { while (state.KeepRunning()) {
auto res = db.get(Resource::tile("mapbox://tile_ambient", 1, 0, 0, 0, Tileset::Scheme::XYZ)); auto res = db.get(Resource::tile("mapbox://tile_ambient", 1, 0, 0, 0, Tileset::Scheme::XYZ));
assert(res == nullopt); assert(res == std::nullopt);
} }
} }

8
bin/offline.cpp
View File

@@ -126,9 +126,9 @@ int main(int argc, char *argv[]) {
std::string style = styleValue ? args::get(styleValue) : mapTilerConfiguration.defaultStyles().at(0).getUrl(); std::string style = styleValue ? args::get(styleValue) : mapTilerConfiguration.defaultStyles().at(0).getUrl();
std::cout << " Style: " << style << std::endl; std::cout << " Style: " << style << std::endl;
mbgl::optional<std::string> mergePath = {}; std::optional<std::string> mergePath = std::nullopt;
if (mergePathValue) mergePath = args::get(mergePathValue); if (mergePathValue) mergePath = args::get(mergePathValue);
mbgl::optional<std::string> inputDb = {}; std::optional<std::string> inputDb = std::nullopt;
if (inputValue) inputDb = args::get(inputValue); if (inputValue) inputDb = args::get(inputValue);
const double minZoom = minZoomValue ? args::get(minZoomValue) : 0.0; const double minZoom = minZoomValue ? args::get(minZoomValue) : 0.0;
@@ -205,7 +205,7 @@ int main(int argc, char *argv[]) {
Observer(OfflineRegion& region_, Observer(OfflineRegion& region_,
std::shared_ptr<DatabaseFileSource> fileSource_, std::shared_ptr<DatabaseFileSource> fileSource_,
util::RunLoop& loop_, util::RunLoop& loop_,
mbgl::optional<std::string> mergePath_) std::optional<std::string> mergePath_)
: region(region_), : region(region_),
fileSource(std::move(fileSource_)), fileSource(std::move(fileSource_)),
loop(loop_), loop(loop_),
@@ -249,7 +249,7 @@ int main(int argc, char *argv[]) {
OfflineRegion& region; OfflineRegion& region;
std::shared_ptr<DatabaseFileSource> fileSource; std::shared_ptr<DatabaseFileSource> fileSource;
util::RunLoop& loop; util::RunLoop& loop;
mbgl::optional<std::string> mergePath; std::optional<std::string> mergePath;
Timestamp start; Timestamp start;
}; };

50
expression-test/expression_test_parser.cpp
View File

@@ -75,7 +75,7 @@ std::string toString(const JSValue& value) {
return { value.GetString(), value.GetStringLength() }; return { value.GetString(), value.GetStringLength() };
} }
optional<Value> toValue(const JSValue& jsvalue) { std::optional<Value> toValue(const JSValue& jsvalue) {
if (jsvalue.IsNull()) { if (jsvalue.IsNull()) {
return Value{}; return Value{};
} }
@@ -105,7 +105,7 @@ optional<Value> toValue(const JSValue& jsvalue) {
return toValue(Convertible(&jsvalue)); return toValue(Convertible(&jsvalue));
} }
return nullopt; return std::nullopt;
} }
style::expression::type::Type stringToType(const std::string& type) { style::expression::type::Type stringToType(const std::string& type) {
@@ -133,7 +133,7 @@ style::expression::type::Type stringToType(const std::string& type) {
return type::Null; return type::Null;
} }
optional<style::expression::type::Type> toExpressionType(const PropertySpec& spec) { std::optional<style::expression::type::Type> toExpressionType(const PropertySpec& spec) {
using namespace style::expression; using namespace style::expression;
if (spec.type == "array") { if (spec.type == "array") {
type::Type itemType = spec.value.empty() ? type::Value : stringToType(spec.value); type::Type itemType = spec.value.empty() ? type::Value : stringToType(spec.value);
@@ -147,7 +147,7 @@ optional<style::expression::type::Type> toExpressionType(const PropertySpec& spe
return {type::String}; return {type::String};
} }
return spec.type.empty() ? nullopt : optional<type::Type>{stringToType(spec.type)}; return spec.type.empty() ? std::nullopt : std::optional<type::Type>{stringToType(spec.type)};
} }
void parseCompiled(const JSValue& compiledValue, TestData& data) { void parseCompiled(const JSValue& compiledValue, TestData& data) {
@@ -246,7 +246,7 @@ bool parseInputs(const JSValue& inputsValue, TestData& data) {
assert(input[1].IsObject()); assert(input[1].IsObject());
// Parse evaluation context, zoom. // Parse evaluation context, zoom.
optional<float> zoom; std::optional<float> zoom;
const auto& evaluationContext = input[0].GetObject(); const auto& evaluationContext = input[0].GetObject();
if (evaluationContext.HasMember("zoom")) { if (evaluationContext.HasMember("zoom")) {
assert(evaluationContext["zoom"].IsNumber()); assert(evaluationContext["zoom"].IsNumber());
@@ -254,14 +254,14 @@ bool parseInputs(const JSValue& inputsValue, TestData& data) {
} }
// Parse heatmap density // Parse heatmap density
optional<double> heatmapDensity; std::optional<double> heatmapDensity;
if (evaluationContext.HasMember("heatmapDensity")) { if (evaluationContext.HasMember("heatmapDensity")) {
assert(evaluationContext["heatmapDensity"].IsNumber()); assert(evaluationContext["heatmapDensity"].IsNumber());
heatmapDensity = evaluationContext["heatmapDensity"].GetDouble(); heatmapDensity = evaluationContext["heatmapDensity"].GetDouble();
} }
// Parse canonicalID // Parse canonicalID
optional<CanonicalTileID> canonical; std::optional<CanonicalTileID> canonical;
if (evaluationContext.HasMember("canonicalID")) { if (evaluationContext.HasMember("canonicalID")) {
const auto& canonicalIDObject = evaluationContext["canonicalID"]; const auto& canonicalIDObject = evaluationContext["canonicalID"];
assert(canonicalIDObject.IsObject()); assert(canonicalIDObject.IsObject());
@@ -344,7 +344,7 @@ std::tuple<filesystem::path, std::vector<filesystem::path>, bool, uint32_t> pars
filesystem::path rootPath {std::string(TEST_RUNNER_ROOT_PATH).append("/maplibre-gl-js/test/integration/expression-tests")}; filesystem::path rootPath {std::string(TEST_RUNNER_ROOT_PATH).append("/maplibre-gl-js/test/integration/expression-tests")};
if (!filesystem::exists(rootPath)) { if (!filesystem::exists(rootPath)) {
Log::Error(Event::General, "Test path '%s' does not exist.", rootPath.string().c_str()); Log::Error(Event::General, "Test path '" + rootPath.string() + "' does not exist.");
exit(3); exit(3);
} }
@@ -363,7 +363,7 @@ std::tuple<filesystem::path, std::vector<filesystem::path>, bool, uint32_t> pars
testPaths.reserve(paths.size()); testPaths.reserve(paths.size());
for (const auto& path : paths) { for (const auto& path : paths) {
if (!filesystem::exists(path)) { if (!filesystem::exists(path)) {
Log::Warning(Event::General, "Provided test folder '%s' does not exist.", path.string().c_str()); Log::Warning(Event::General, "Provided test folder '" + path.string() + "' does not exist.");
continue; continue;
} }
@@ -404,20 +404,20 @@ Ignores parseExpressionIgnores() {
return ignores; return ignores;
} }
optional<TestData> parseTestData(const filesystem::path& path) { std::optional<TestData> parseTestData(const filesystem::path& path) {
TestData data; TestData data;
auto maybeJson = readJson(path.string()); auto maybeJson = readJson(path.string());
if (!maybeJson.is<JSDocument>()) { // NOLINT if (!maybeJson.is<JSDocument>()) { // NOLINT
Log::Error(Event::General, "Cannot parse test '%s'.", path.string().c_str()); mbgl::Log::Error(mbgl::Event::General, "Cannot parse test '" + path.string() + "'.");
return nullopt; return std::nullopt;
} }
data.document = std::move(maybeJson.get<JSDocument>()); data.document = std::move(maybeJson.get<JSDocument>());
// Check that mandatory test data members are present. // Check that mandatory test data members are present.
if (!data.document.HasMember("expression") || !data.document.HasMember("expected")) { if (!data.document.HasMember("expression") || !data.document.HasMember("expected")) {
Log::Error(Event::General, "Test fixture '%s' does not contain required data.", path.string().c_str()); Log::Error(Event::General, "Test fixture '" + path.string() + "' does not contain required data.");
return nullopt; return std::nullopt;
} }
// Parse propertySpec // Parse propertySpec
@@ -431,8 +431,8 @@ optional<TestData> parseTestData(const filesystem::path& path) {
// Parse inputs // Parse inputs
if (data.document.HasMember("inputs") && !parseInputs(data.document["inputs"], data)) { if (data.document.HasMember("inputs") && !parseInputs(data.document["inputs"], data)) {
Log::Error(Event::General,"Can't convert inputs value for '%s'", path.string().c_str()); Log::Error(Event::General, std::string("Can't convert inputs value for '") + path.string() + "'");
return nullopt; return std::nullopt;
} }
return {std::move(data)}; return {std::move(data)};
@@ -471,14 +471,14 @@ Value toValue(const Compiled& compiled) {
// Serializes native expression types to JS format. // Serializes native expression types to JS format.
// Color and Formatted are exceptions. // Color and Formatted are exceptions.
// TODO: harmonize serialized format to remove this conversion. // TODO: harmonize serialized format to remove this conversion.
optional<Value> toValue(const expression::Value& exprValue) { std::optional<Value> toValue(const expression::Value& exprValue) {
return exprValue.match( return exprValue.match(
[](const Color& c) -> optional<Value> { [](const Color& c) -> std::optional<Value> {
std::vector<Value> color { static_cast<double>(c.r), static_cast<double>(c.g), static_cast<double>(c.b), static_cast<double>(c.a) }; std::vector<Value> color { static_cast<double>(c.r), static_cast<double>(c.g), static_cast<double>(c.b), static_cast<double>(c.a) };
return {Value{std::move(color)}}; return {Value{std::move(color)}};
}, },
[](const expression::Formatted& formatted) -> optional<Value> { return {formatted.toObject()}; }, [](const expression::Formatted& formatted) -> std::optional<Value> { return {formatted.toObject()}; },
[](const std::vector<expression::Value>& values) -> optional<Value> { [](const std::vector<expression::Value>& values) -> std::optional<Value> {
std::vector<Value> mbglValues; std::vector<Value> mbglValues;
for (const auto& value : values) { for (const auto& value : values) {
if (auto converted = expression::fromExpressionValue<Value>(value)) { if (auto converted = expression::fromExpressionValue<Value>(value)) {
@@ -487,7 +487,7 @@ optional<Value> toValue(const expression::Value& exprValue) {
} }
return {Value{std::move(mbglValues)}}; return {Value{std::move(mbglValues)}};
}, },
[](const std::unordered_map<std::string, expression::Value>& valueMap) -> optional<Value> { [](const std::unordered_map<std::string, expression::Value>& valueMap) -> std::optional<Value> {
std::unordered_map<std::string, Value> mbglValueMap; std::unordered_map<std::string, Value> mbglValueMap;
for (const auto& pair : valueMap) { for (const auto& pair : valueMap) {
if (auto converted = expression::fromExpressionValue<Value>(pair.second)) { if (auto converted = expression::fromExpressionValue<Value>(pair.second)) {
@@ -500,9 +500,9 @@ optional<Value> toValue(const expression::Value& exprValue) {
} }
std::unique_ptr<style::expression::Expression> parseExpression(const JSValue& value, std::unique_ptr<style::expression::Expression> parseExpression(const JSValue& value,
optional<PropertySpec>& spec, std::optional<PropertySpec>& spec,
TestResult& result) { TestResult& result) {
optional<style::expression::type::Type> expected = spec ? toExpressionType(*spec) : nullopt; std::optional<style::expression::type::Type> expected = spec ? toExpressionType(*spec) : std::nullopt;
expression::ParsingContext ctx = expected ? expression::ParsingContext(*expected) : expression::ParsingContext ctx = expected ? expression::ParsingContext(*expected) :
expression::ParsingContext(); expression::ParsingContext();
Convertible convertible(&value); Convertible convertible(&value);
@@ -538,8 +538,8 @@ std::unique_ptr<style::expression::Expression> parseExpression(const JSValue& va
return nullptr; return nullptr;
} }
std::unique_ptr<style::expression::Expression> parseExpression(const optional<Value>& value, std::unique_ptr<style::expression::Expression> parseExpression(const std::optional<Value>& value,
optional<PropertySpec>& spec, std::optional<PropertySpec>& spec,
TestResult& result) { TestResult& result) {
assert(value); assert(value);
auto document = toDocument(*value); auto document = toDocument(*value);

33
expression-test/expression_test_parser.hpp
View File

@@ -4,7 +4,6 @@
#include <mbgl/style/expression/expression.hpp> #include <mbgl/style/expression/expression.hpp>
#include <mbgl/util/feature.hpp> #include <mbgl/util/feature.hpp>
#include <mbgl/util/optional.hpp>
#include <mbgl/util/rapidjson.hpp> #include <mbgl/util/rapidjson.hpp>
#include <set> #include <set>
@@ -14,9 +13,9 @@
using namespace mbgl; using namespace mbgl;
struct Input { struct Input {
Input(optional<float> zoom_, Input(std::optional<float> zoom_,
optional<double> heatmapDensity_, std::optional<double> heatmapDensity_,
optional<CanonicalTileID> canonical_, std::optional<CanonicalTileID> canonical_,
std::set<std::string> availableImages_, std::set<std::string> availableImages_,
Feature feature_) Feature feature_)
: zoom(std::move(zoom_)), : zoom(std::move(zoom_)),
@@ -24,9 +23,9 @@ struct Input {
canonical(std::move(canonical_)), canonical(std::move(canonical_)),
availableImages(std::move(availableImages_)), availableImages(std::move(availableImages_)),
feature(std::move(feature_)) {} feature(std::move(feature_)) {}
optional<float> zoom; std::optional<float> zoom;
optional<double> heatmapDensity; std::optional<double> heatmapDensity;
optional<CanonicalTileID> canonical; std::optional<CanonicalTileID> canonical;
std::set<std::string> availableImages; std::set<std::string> availableImages;
Feature feature; Feature feature;
}; };
@@ -50,9 +49,9 @@ struct Compiled {
struct TestResult { struct TestResult {
Compiled compiled; Compiled compiled;
optional<Value> expression; std::optional<Value> expression;
optional<Value> outputs; std::optional<Value> outputs;
optional<Value> serialized; std::optional<Value> serialized;
}; };
struct PropertySpec { struct PropertySpec {
@@ -60,7 +59,7 @@ struct PropertySpec {
std::string value; std::string value;
std::size_t length = 0; std::size_t length = 0;
bool isDataDriven = false; bool isDataDriven = false;
optional<Value> expression; std::optional<Value> expression;
}; };
class TestData { class TestData {
@@ -69,7 +68,7 @@ public:
TestResult expected; TestResult expected;
TestResult result; TestResult result;
TestResult recompiled; TestResult recompiled;
optional<PropertySpec> spec; std::optional<PropertySpec> spec;
JSDocument document; JSDocument document;
}; };
@@ -87,17 +86,17 @@ Arguments parseArguments(int argc, char** argv);
using Ignores = std::vector<Ignore>; using Ignores = std::vector<Ignore>;
Ignores parseExpressionIgnores(); Ignores parseExpressionIgnores();
optional<TestData> parseTestData(const filesystem::path&); std::optional<TestData> parseTestData(const filesystem::path&);
std::string toJSON(const Value& value, unsigned indent = 0, bool singleLine = false); std::string toJSON(const Value& value, unsigned indent = 0, bool singleLine = false);
JSDocument toDocument(const Value&); JSDocument toDocument(const Value&);
Value toValue(const Compiled&); Value toValue(const Compiled&);
optional<Value> toValue(const style::expression::Value&); std::optional<Value> toValue(const style::expression::Value&);
std::unique_ptr<style::expression::Expression> parseExpression(const JSValue&, std::unique_ptr<style::expression::Expression> parseExpression(const JSValue&,
optional<PropertySpec>&, std::optional<PropertySpec>&,
TestResult&); TestResult&);
std::unique_ptr<style::expression::Expression> parseExpression(const optional<Value>&, std::unique_ptr<style::expression::Expression> parseExpression(const std::optional<Value>&,
optional<PropertySpec>&, std::optional<PropertySpec>&,
TestResult&); TestResult&);

2
expression-test/main.cpp
View File

@@ -40,7 +40,7 @@ try {
ignoreReason = (*it).reason; ignoreReason = (*it).reason;
} }
optional<TestRunOutput> testRun; std::optional<TestRunOutput> testRun;
if (auto testData = parseTestData(path)) { if (auto testData = parseTestData(path)) {
testRun = runExpressionTest(*testData, rootPath.string(), id); testRun = runExpressionTest(*testData, rootPath.string(), id);
} }

2
expression-test/test_runner_common.cpp
View File

@@ -118,7 +118,7 @@ bool deepEqual(const Value& a, const Value& b) {
return false; return false;
} }
bool deepEqual(const optional<Value>& a, const optional<Value>& b) { bool deepEqual(const std::optional<Value>& a, const std::optional<Value>& b) {
if ((a && !b) || (!a && b)) { if ((a && !b) || (!a && b)) {
return false; return false;
} }

2
expression-test/test_runner_common.hpp
View File

@@ -10,4 +10,4 @@ using namespace mbgl;
Value stripPrecision(const Value& value); Value stripPrecision(const Value& value);
std::vector<std::string> tokenize(std::string str); std::vector<std::string> tokenize(std::string str);
bool deepEqual(const Value& a, const Value& b); bool deepEqual(const Value& a, const Value& b);
bool deepEqual(const optional<Value>& a, const optional<Value>& b); bool deepEqual(const std::optional<Value>& a, const std::optional<Value>& b);

2
include/mbgl/actor/mailbox.hpp
View File

@@ -1,7 +1,5 @@
#pragma once #pragma once
#include <mbgl/util/optional.hpp>
#include <functional> #include <functional>
#include <memory> #include <memory>
#include <mutex> #include <mutex>

2
include/mbgl/actor/message.hpp
View File

@@ -1,7 +1,5 @@
#pragma once #pragma once
#include <mbgl/util/optional.hpp>
#include <future> #include <future>
#include <utility> #include <utility>

4
include/mbgl/gl/custom_layer.hpp
View File

@@ -73,8 +73,8 @@ public:
Mutable<Impl> mutableImpl() const; Mutable<Impl> mutableImpl() const;
private: private:
optional<conversion::Error> setPropertyInternal(const std::string& name, std::optional<conversion::Error> setPropertyInternal(const std::string& name,
const conversion::Convertible& value) final; const conversion::Convertible& value) final;
StyleProperty getProperty(const std::string&) const final; StyleProperty getProperty(const std::string&) const final;
std::unique_ptr<Layer> cloneRef(const std::string& id) const final; std::unique_ptr<Layer> cloneRef(const std::string& id) const final;
Mutable<Layer::Impl> mutableBaseImpl() const final; Mutable<Layer::Impl> mutableBaseImpl() const final;

5
include/mbgl/i18n/collator.hpp
View File

@@ -1,16 +1,15 @@
#pragma once #pragma once
#include <mbgl/util/optional.hpp>
#include <memory> #include <memory>
#include <string> #include <string>
#include <optional>
namespace mbgl { namespace mbgl {
namespace platform { namespace platform {
class Collator { class Collator {
public: public:
explicit Collator(bool caseSensitive, bool diacriticSensitive, const optional<std::string>& locale = nullopt); explicit Collator(bool caseSensitive, bool diacriticSensitive, const std::optional<std::string>& locale = std::nullopt);
int compare(const std::string& lhs, const std::string& rhs) const; int compare(const std::string& lhs, const std::string& rhs) const;
std::string resolvedLocale() const; std::string resolvedLocale() const;
bool operator==(const Collator& other) const; bool operator==(const Collator& other) const;

2
include/mbgl/layermanager/layer_factory.hpp
View File

@@ -36,7 +36,7 @@ public:
virtual std::unique_ptr<Layout> createLayout(const LayoutParameters&, std::unique_ptr<GeometryTileLayer>, const std::vector<Immutable<style::LayerProperties>>&) noexcept; virtual std::unique_ptr<Layout> createLayout(const LayoutParameters&, std::unique_ptr<GeometryTileLayer>, const std::vector<Immutable<style::LayerProperties>>&) noexcept;
protected: protected:
optional<std::string> getSource(const style::conversion::Convertible& value) const noexcept; std::optional<std::string> getSource(const style::conversion::Convertible& value) const noexcept;
}; };
} // namespace mbgl } // namespace mbgl

13
include/mbgl/map/bound_options.hpp
View File

@@ -1,7 +1,8 @@
#pragma once #pragma once
#include <mbgl/util/geo.hpp> #include <mbgl/util/geo.hpp>
#include <mbgl/util/optional.hpp>
#include <optional>
namespace mbgl { namespace mbgl {
@@ -28,19 +29,19 @@ struct BoundOptions {
} }
/// Constrain the center of the camera to be within these bounds. /// Constrain the center of the camera to be within these bounds.
optional<LatLngBounds> bounds; std::optional<LatLngBounds> bounds;
/// Maximum zoom level allowed. /// Maximum zoom level allowed.
optional<double> maxZoom; std::optional<double> maxZoom;
/// Minimum zoom level allowed. /// Minimum zoom level allowed.
optional<double> minZoom; std::optional<double> minZoom;
/// Maximum pitch allowed in degrees. /// Maximum pitch allowed in degrees.
optional<double> maxPitch; std::optional<double> maxPitch;
/// Minimum pitch allowed in degrees. /// Minimum pitch allowed in degrees.
optional<double> minPitch; std::optional<double> minPitch;
}; };
} // namespace mbgl } // namespace mbgl

43
include/mbgl/map/camera.hpp
View File

@@ -2,10 +2,11 @@
#include <mbgl/util/chrono.hpp> #include <mbgl/util/chrono.hpp>
#include <mbgl/util/geo.hpp> #include <mbgl/util/geo.hpp>
#include <mbgl/util/optional.hpp>
#include <mbgl/util/unitbezier.hpp> #include <mbgl/util/unitbezier.hpp>
#include <mbgl/util/vectors.hpp> #include <mbgl/util/vectors.hpp>
#include <optional>
#include <functional> #include <functional>
namespace mbgl { namespace mbgl {
@@ -16,34 +17,34 @@ namespace mbgl {
center point when both are set. center point when both are set.
*/ */
struct CameraOptions { struct CameraOptions {
CameraOptions& withCenter(const optional<LatLng>& o) { center = o; return *this; } CameraOptions& withCenter(const std::optional<LatLng>& o) { center = o; return *this; }
CameraOptions& withPadding(const optional<EdgeInsets>& p) { padding = p; return *this; } CameraOptions& withPadding(const std::optional<EdgeInsets>& p) { padding = p; return *this; }
CameraOptions& withAnchor(const optional<ScreenCoordinate>& o) { anchor = o; return *this; } CameraOptions& withAnchor(const std::optional<ScreenCoordinate>& o) { anchor = o; return *this; }
CameraOptions& withZoom(const optional<double>& o) { zoom = o; return *this; } CameraOptions& withZoom(const std::optional<double>& o) { zoom = o; return *this; }
CameraOptions& withBearing(const optional<double>& o) { bearing = o; return *this; } CameraOptions& withBearing(const std::optional<double>& o) { bearing = o; return *this; }
CameraOptions& withPitch(const optional<double>& o) { pitch = o; return *this; } CameraOptions& withPitch(const std::optional<double>& o) { pitch = o; return *this; }
/** Coordinate at the center of the map. */ /** Coordinate at the center of the map. */
optional<LatLng> center; std::optional<LatLng> center;
/** Padding around the interior of the view that affects the frame of /** Padding around the interior of the view that affects the frame of
reference for `center`. */ reference for `center`. */
optional<EdgeInsets> padding; std::optional<EdgeInsets> padding;
/** Point of reference for `zoom` and `angle`, assuming an origin at the /** Point of reference for `zoom` and `angle`, assuming an origin at the
top-left corner of the view. */ top-left corner of the view. */
optional<ScreenCoordinate> anchor; std::optional<ScreenCoordinate> anchor;
/** Zero-based zoom level. Constrained to the minimum and maximum zoom /** Zero-based zoom level. Constrained to the minimum and maximum zoom
levels. */ levels. */
optional<double> zoom; std::optional<double> zoom;
/** Bearing, measured in degrees from true north. Wrapped to [0, 360). */ /** Bearing, measured in degrees from true north. Wrapped to [0, 360). */
optional<double> bearing; std::optional<double> bearing;
/** Pitch toward the horizon measured in degrees , with 0 deg resulting in a /** Pitch toward the horizon measured in degrees , with 0 deg resulting in a
two-dimensional map. */ two-dimensional map. */
optional<double> pitch; std::optional<double> pitch;
}; };
constexpr bool operator==(const CameraOptions& a, const CameraOptions& b) { constexpr bool operator==(const CameraOptions& a, const CameraOptions& b) {
@@ -64,21 +65,21 @@ constexpr bool operator!=(const CameraOptions& a, const CameraOptions& b) {
struct is used. */ struct is used. */
struct AnimationOptions { struct AnimationOptions {
/** Time to animate to the viewpoint defined herein. */ /** Time to animate to the viewpoint defined herein. */
optional<Duration> duration; std::optional<Duration> duration;
/** Average velocity of a flyTo() transition, measured in screenfuls per /** Average velocity of a flyTo() transition, measured in screenfuls per
second, assuming a linear timing curve. second, assuming a linear timing curve.
A <i>screenful</i> is the visible span in pixels. It does not correspond A <i>screenful</i> is the visible span in pixels. It does not correspond
to a fixed physical distance but rather varies by zoom level. */ to a fixed physical distance but rather varies by zoom level. */
optional<double> velocity; std::optional<double> velocity;
/** Zero-based zoom level at the peak of the flyTo() transition’s flight /** Zero-based zoom level at the peak of the flyTo() transition’s flight
path. */ path. */
optional<double> minZoom; std::optional<double> minZoom;
/** The easing timing curve of the transition. */ /** The easing timing curve of the transition. */
optional<mbgl::util::UnitBezier> easing; std::optional<mbgl::util::UnitBezier> easing;
/** A function that is called on each frame of the transition, just before a /** A function that is called on each frame of the transition, just before a
screen update, except on the last frame. The first parameter indicates screen update, except on the last frame. The first parameter indicates
@@ -107,7 +108,7 @@ struct FreeCameraOptions {
- Z coordinate is conformal and must respect minimum and maximum zoom values. - Z coordinate is conformal and must respect minimum and maximum zoom values.
- Zoom is automatically computed from the altitude (z) - Zoom is automatically computed from the altitude (z)
*/ */
optional<vec3> position = nullopt; std::optional<vec3> position = std::nullopt;
/** Orientation of the camera represented as a unit quaternion [x, y, z, w]. /** Orientation of the camera represented as a unit quaternion [x, y, z, w].
The default pose of the camera is such that the forward vector is looking up the -Z axis and The default pose of the camera is such that the forward vector is looking up the -Z axis and
@@ -119,19 +120,19 @@ struct FreeCameraOptions {
Orientation can be set freely but certain constraints still apply Orientation can be set freely but certain constraints still apply
- Orientation must be representable with only pitch and bearing. - Orientation must be representable with only pitch and bearing.
- Pitch has an upper limit */ - Pitch has an upper limit */
optional<vec4> orientation = nullopt; std::optional<vec4> orientation = std::nullopt;
/** Helper function for setting the mercator position as Lat&Lng and altitude in meters */ /** Helper function for setting the mercator position as Lat&Lng and altitude in meters */
void setLocation(const LatLngAltitude& location); void setLocation(const LatLngAltitude& location);
/** Helper function for converting mercator position into Lat&Lng and altitude in meters. /** Helper function for converting mercator position into Lat&Lng and altitude in meters.
This function fails to return a value if `position` is invalid or is not set */ This function fails to return a value if `position` is invalid or is not set */
optional<LatLngAltitude> getLocation() const; std::optional<LatLngAltitude> getLocation() const;
/** Helper function for setting orientation of the camera by defining a focus point /** Helper function for setting orientation of the camera by defining a focus point
on the map. Up vector is required in certain scenarios where bearing can't be deduced on the map. Up vector is required in certain scenarios where bearing can't be deduced
from the viewing direction */ from the viewing direction */
void lookAtPoint(const LatLng& location, const optional<vec3>& upVector = nullopt); void lookAtPoint(const LatLng& location, const std::optional<vec3>& upVector = std::nullopt);
/** Helper function for setting the orientation of the camera as a pitch and a bearing. /** Helper function for setting the orientation of the camera as a pitch and a bearing.
Both values are in degrees */ Both values are in degrees */

18
include/mbgl/map/map.hpp
View File

@@ -1,6 +1,5 @@
#pragma once #pragma once
#include <mbgl/util/optional.hpp>
#include <mbgl/util/chrono.hpp> #include <mbgl/util/chrono.hpp>
#include <mbgl/map/bound_options.hpp> #include <mbgl/map/bound_options.hpp>
#include <mbgl/map/map_observer.hpp> #include <mbgl/map/map_observer.hpp>
@@ -20,6 +19,7 @@
#include <functional> #include <functional>
#include <vector> #include <vector>
#include <memory> #include <memory>
#include <optional>
namespace mbgl { namespace mbgl {
@@ -63,26 +63,26 @@ public:
bool isPanning() const; bool isPanning() const;
// Camera // Camera
CameraOptions getCameraOptions(const optional<EdgeInsets>& = {}) const; CameraOptions getCameraOptions(const std::optional<EdgeInsets>& = std::nullopt) const;
void jumpTo(const CameraOptions&); void jumpTo(const CameraOptions&);
void easeTo(const CameraOptions&, const AnimationOptions&); void easeTo(const CameraOptions&, const AnimationOptions&);
void flyTo(const CameraOptions&, const AnimationOptions&); void flyTo(const CameraOptions&, const AnimationOptions&);
void moveBy(const ScreenCoordinate&, const AnimationOptions& = {}); void moveBy(const ScreenCoordinate&, const AnimationOptions& = {});
void scaleBy(double scale, const optional<ScreenCoordinate>& anchor, const AnimationOptions& animation = {}); void scaleBy(double scale, const std::optional<ScreenCoordinate>& anchor, const AnimationOptions& animation = {});
void pitchBy(double pitch, const AnimationOptions& animation = {}); void pitchBy(double pitch, const AnimationOptions& animation = {});
void rotateBy(const ScreenCoordinate& first, const ScreenCoordinate& second, const AnimationOptions& = {}); void rotateBy(const ScreenCoordinate& first, const ScreenCoordinate& second, const AnimationOptions& = {});
CameraOptions cameraForLatLngBounds(const LatLngBounds&, CameraOptions cameraForLatLngBounds(const LatLngBounds&,
const EdgeInsets&, const EdgeInsets&,
const optional<double>& bearing = {}, const std::optional<double>& bearing = std::nullopt,
const optional<double>& pitch = {}) const; const std::optional<double>& pitch = std::nullopt) const;
CameraOptions cameraForLatLngs(const std::vector<LatLng>&, CameraOptions cameraForLatLngs(const std::vector<LatLng>&,
const EdgeInsets&, const EdgeInsets&,
const optional<double>& bearing = {}, const std::optional<double>& bearing = std::nullopt,
const optional<double>& pitch = {}) const; const std::optional<double>& pitch = std::nullopt) const;
CameraOptions cameraForGeometry(const Geometry<double>&, CameraOptions cameraForGeometry(const Geometry<double>&,
const EdgeInsets&, const EdgeInsets&,
const optional<double>& bearing = {}, const std::optional<double>& bearing = std::nullopt,
const optional<double>& pitch = {}) const; const std::optional<double>& pitch = std::nullopt) const;
LatLngBounds latLngBoundsForCamera(const CameraOptions&) const; LatLngBounds latLngBoundsForCamera(const CameraOptions&) const;
LatLngBounds latLngBoundsForCameraUnwrapped(const CameraOptions&) const; LatLngBounds latLngBoundsForCameraUnwrapped(const CameraOptions&) const;

9
include/mbgl/map/projection_mode.hpp
View File

@@ -1,8 +1,7 @@
#pragma once #pragma once
#include <mbgl/util/optional.hpp>
#include <functional> #include <functional>
#include <optional>
namespace mbgl { namespace mbgl {
@@ -18,17 +17,17 @@ struct ProjectionMode {
/** /**
* @brief Set to True to enable axonometric rendering, false otherwise. * @brief Set to True to enable axonometric rendering, false otherwise.
*/ */
optional<bool> axonometric; std::optional<bool> axonometric;
/** /**
* @brief The X skew value represents how much to skew on the x-axis. * @brief The X skew value represents how much to skew on the x-axis.
*/ */
optional<double> xSkew; std::optional<double> xSkew;
/** /**
* @brief The Y skew value represents how much to skew on the y-axis. * @brief The Y skew value represents how much to skew on the y-axis.
*/ */
optional<double> ySkew; std::optional<double> ySkew;
}; };
} // namespace mbgl } // namespace mbgl

18
include/mbgl/renderer/query.hpp
View File

@@ -1,10 +1,10 @@
#pragma once #pragma once
#include <mbgl/util/optional.hpp>
#include <mbgl/style/filter.hpp> #include <mbgl/style/filter.hpp>
#include <string> #include <string>
#include <vector> #include <vector>
#include <optional>
namespace mbgl { namespace mbgl {
@@ -13,15 +13,15 @@ namespace mbgl {
*/ */
class RenderedQueryOptions { class RenderedQueryOptions {
public: public:
RenderedQueryOptions(optional<std::vector<std::string>> layerIDs_ = {}, RenderedQueryOptions(std::optional<std::vector<std::string>> layerIDs_ = std::nullopt,
optional<style::Filter> filter_ = {}) std::optional<style::Filter> filter_ = std::nullopt)
: layerIDs(std::move(layerIDs_)), : layerIDs(std::move(layerIDs_)),
filter(std::move(filter_)) {} filter(std::move(filter_)) {}
/** layerIDs to include in the query */ /** layerIDs to include in the query */
optional<std::vector<std::string>> layerIDs; std::optional<std::vector<std::string>> layerIDs;
optional<style::Filter> filter; std::optional<style::Filter> filter;
}; };
/** /**
@@ -29,15 +29,15 @@ public:
*/ */
class SourceQueryOptions { class SourceQueryOptions {
public: public:
SourceQueryOptions(optional<std::vector<std::string>> sourceLayers_ = {}, SourceQueryOptions(std::optional<std::vector<std::string>> sourceLayers_ = std::nullopt,
optional<style::Filter> filter_ = {}) std::optional<style::Filter> filter_ = std::nullopt)
: sourceLayers(std::move(sourceLayers_)), : sourceLayers(std::move(sourceLayers_)),
filter(std::move(filter_)) {} filter(std::move(filter_)) {}
/// Required for VectorSource, ignored for GeoJSONSource /// Required for VectorSource, ignored for GeoJSONSource
optional<std::vector<std::string>> sourceLayers; std::optional<std::vector<std::string>> sourceLayers;
optional<style::Filter> filter; std::optional<style::Filter> filter;
}; };
} // namespace mbgl } // namespace mbgl

18
include/mbgl/renderer/renderer.hpp
View File

@@ -25,9 +25,9 @@ struct PlacedSymbolData {
/// Contents of the label /// Contents of the label
std::u16string key; std::u16string key;
/// If symbol contains text, text collision box in viewport coordinates /// If symbol contains text, text collision box in viewport coordinates
optional<mapbox::geometry::box<float>> textCollisionBox; std::optional<mapbox::geometry::box<float>> textCollisionBox;
/// If symbol contains icon, icon collision box in viewport coordinates /// If symbol contains icon, icon collision box in viewport coordinates
optional<mapbox::geometry::box<float>> iconCollisionBox; std::optional<mapbox::geometry::box<float>> iconCollisionBox;
/// Symbol text was placed /// Symbol text was placed
bool textPlaced; bool textPlaced;
/// Symbol icon was placed /// Symbol icon was placed
@@ -42,7 +42,7 @@ struct PlacedSymbolData {
class Renderer { class Renderer {
public: public:
Renderer(gfx::RendererBackend&, float pixelRatio_, const optional<std::string>& localFontFamily = {}); Renderer(gfx::RendererBackend&, float pixelRatio_, const std::optional<std::string>& localFontFamily = std::nullopt);
~Renderer(); ~Renderer();
void markContextLost(); void markContextLost();
@@ -65,20 +65,20 @@ public:
const Feature& feature, const Feature& feature,
const std::string& extension, const std::string& extension,
const std::string& extensionField, const std::string& extensionField,
const optional<std::map<std::string, Value>>& args = {}) const; const std::optional<std::map<std::string, Value>>& args = std::nullopt) const;
void setFeatureState(const std::string& sourceID, const optional<std::string>& sourceLayerID, void setFeatureState(const std::string& sourceID, const std::optional<std::string>& sourceLayerID,
const std::string& featureID, const FeatureState& state); const std::string& featureID, const FeatureState& state);
void getFeatureState(FeatureState& state, void getFeatureState(FeatureState& state,
const std::string& sourceID, const std::string& sourceID,
const optional<std::string>& sourceLayerID, const std::optional<std::string>& sourceLayerID,
const std::string& featureID) const; const std::string& featureID) const;
void removeFeatureState(const std::string& sourceID, void removeFeatureState(const std::string& sourceID,
const optional<std::string>& sourceLayerID, const std::optional<std::string>& sourceLayerID,
const optional<std::string>& featureID, const std::optional<std::string>& featureID,
const optional<std::string>& stateKey); const std::optional<std::string>& stateKey);
// Debug // Debug
void dumpDebugLogs(); void dumpDebugLogs();

1
include/mbgl/storage/database_file_source.hpp
View File

@@ -3,7 +3,6 @@
#include <mbgl/storage/file_source.hpp> #include <mbgl/storage/file_source.hpp>
#include <mbgl/storage/offline.hpp> #include <mbgl/storage/offline.hpp>
#include <mbgl/util/expected.hpp> #include <mbgl/util/expected.hpp>
#include <mbgl/util/optional.hpp>
namespace mbgl { namespace mbgl {

1
include/mbgl/storage/offline.hpp
View File

@@ -3,7 +3,6 @@
#include <mbgl/util/geo.hpp> #include <mbgl/util/geo.hpp>
#include <mbgl/util/geometry.hpp> #include <mbgl/util/geometry.hpp>
#include <mbgl/util/range.hpp> #include <mbgl/util/range.hpp>
#include <mbgl/util/optional.hpp>
#include <mbgl/util/variant.hpp> #include <mbgl/util/variant.hpp>
#include <mbgl/style/types.hpp> #include <mbgl/style/types.hpp>
#include <mbgl/storage/response.hpp> #include <mbgl/storage/response.hpp>

3
include/mbgl/storage/online_file_source.hpp
View File

@@ -3,7 +3,8 @@
#include <mbgl/storage/file_source.hpp> #include <mbgl/storage/file_source.hpp>
#include <mbgl/storage/resource_options.hpp> #include <mbgl/storage/resource_options.hpp>
#include <mbgl/util/client_options.hpp> #include <mbgl/util/client_options.hpp>
#include <mbgl/util/optional.hpp>
#include <optional>
namespace mbgl { namespace mbgl {

12
include/mbgl/storage/resource.hpp
View File

@@ -2,11 +2,11 @@
#include <mbgl/storage/response.hpp> #include <mbgl/storage/response.hpp>
#include <mbgl/util/bitmask_operations.hpp> #include <mbgl/util/bitmask_operations.hpp>
#include <mbgl/util/optional.hpp>
#include <mbgl/util/font_stack.hpp> #include <mbgl/util/font_stack.hpp>
#include <mbgl/util/tileset.hpp> #include <mbgl/util/tileset.hpp>
#include <string> #include <string>
#include <optional>
namespace mbgl { namespace mbgl {
@@ -55,7 +55,7 @@ public:
Resource(Kind kind_, Resource(Kind kind_,
std::string url_, std::string url_,
optional<TileData> tileData_ = {}, std::optional<TileData> tileData_ = std::nullopt,
LoadingMethod loadingMethod_ = LoadingMethod::All) LoadingMethod loadingMethod_ = LoadingMethod::All)
: kind(kind_), : kind(kind_),
loadingMethod(loadingMethod_), loadingMethod(loadingMethod_),
@@ -91,11 +91,11 @@ public:
std::string url; std::string url;
// Includes auxiliary data if this is a tile request. // Includes auxiliary data if this is a tile request.
optional<TileData> tileData; std::optional<TileData> tileData;
optional<Timestamp> priorModified = {}; std::optional<Timestamp> priorModified = std::nullopt;
optional<Timestamp> priorExpires = {}; std::optional<Timestamp> priorExpires = std::nullopt;
optional<std::string> priorEtag = {}; std::optional<std::string> priorEtag = std::nullopt;
std::shared_ptr<const std::string> priorData; std::shared_ptr<const std::string> priorData;
Duration minimumUpdateInterval{Duration::zero()}; Duration minimumUpdateInterval{Duration::zero()};
StoragePolicy storagePolicy{StoragePolicy::Permanent}; StoragePolicy storagePolicy{StoragePolicy::Permanent};

12
include/mbgl/storage/response.hpp
View File

@@ -1,8 +1,8 @@
#pragma once #pragma once
#include <mbgl/util/chrono.hpp> #include <mbgl/util/chrono.hpp>
#include <mbgl/util/optional.hpp>
#include <optional>
#include <string> #include <string>
#include <memory> #include <memory>
@@ -33,9 +33,9 @@ public:
// The actual data of the response. Present only for non-error, non-notModified responses. // The actual data of the response. Present only for non-error, non-notModified responses.
std::shared_ptr<const std::string> data; std::shared_ptr<const std::string> data;
optional<Timestamp> modified; std::optional<Timestamp> modified;
optional<Timestamp> expires; std::optional<Timestamp> expires;
optional<std::string> etag; std::optional<std::string> etag;
bool isFresh() const { bool isFresh() const {
return expires ? *expires > util::now() : !error; return expires ? *expires > util::now() : !error;
@@ -63,10 +63,10 @@ public:
// informing the user about the reason for the failure. // informing the user about the reason for the failure.
std::string message; std::string message;
optional<Timestamp> retryAfter; std::optional<Timestamp> retryAfter;
public: public:
Error(Reason, std::string = "", optional<Timestamp> = {}); Error(Reason, std::string = "", std::optional<Timestamp> = std::nullopt);
}; };
} // namespace mbgl } // namespace mbgl

2
include/mbgl/style/conversion/color_ramp_property_value.hpp
View File

@@ -9,7 +9,7 @@ namespace conversion {
template <> template <>
struct Converter<ColorRampPropertyValue> { struct Converter<ColorRampPropertyValue> {
optional<ColorRampPropertyValue> operator()(const Convertible& value, Error& error, bool /* allowDataExpressions */ = false, bool /* convertTokens */ = false) const; std::optional<ColorRampPropertyValue> operator()(const Convertible& value, Error& error, bool /* allowDataExpressions */ = false, bool /* convertTokens */ = false) const;
}; };
} // namespace conversion } // namespace conversion

20
include/mbgl/style/conversion/constant.hpp
View File

@@ -16,52 +16,52 @@ namespace conversion {
template <> template <>
struct Converter<bool> { struct Converter<bool> {
optional<bool> operator()(const Convertible& value, Error& error) const; std::optional<bool> operator()(const Convertible& value, Error& error) const;
}; };
template <> template <>
struct Converter<float> { struct Converter<float> {
optional<float> operator()(const Convertible& value, Error& error) const; std::optional<float> operator()(const Convertible& value, Error& error) const;
}; };
template <> template <>
struct Converter<std::string> { struct Converter<std::string> {
optional<std::string> operator()(const Convertible& value, Error& error) const; std::optional<std::string> operator()(const Convertible& value, Error& error) const;
}; };
template <class T> template <class T>
struct Converter<T, typename std::enable_if_t<std::is_enum_v<T>>> { struct Converter<T, typename std::enable_if_t<std::is_enum_v<T>>> {
optional<T> operator()(const Convertible& value, Error& error) const; std::optional<T> operator()(const Convertible& value, Error& error) const;
}; };
template <class T> template <class T>
struct Converter<std::vector<T>, typename std::enable_if_t<std::is_enum_v<T>>> { struct Converter<std::vector<T>, typename std::enable_if_t<std::is_enum_v<T>>> {
optional<std::vector<T>> operator()(const Convertible& value, Error& error) const; std::optional<std::vector<T>> operator()(const Convertible& value, Error& error) const;
}; };
template <> template <>
struct Converter<Color> { struct Converter<Color> {
optional<Color> operator()(const Convertible& value, Error& error) const; std::optional<Color> operator()(const Convertible& value, Error& error) const;
}; };
template <size_t N> template <size_t N>
struct Converter<std::array<float, N>> { struct Converter<std::array<float, N>> {
optional<std::array<float, N>> operator()(const Convertible& value, Error& error) const; std::optional<std::array<float, N>> operator()(const Convertible& value, Error& error) const;
}; };
template <> template <>
struct Converter<std::vector<float>> { struct Converter<std::vector<float>> {
optional<std::vector<float>> operator()(const Convertible& value, Error& error) const; std::optional<std::vector<float>> operator()(const Convertible& value, Error& error) const;
}; };
template <size_t N> template <size_t N>
struct Converter<std::array<double, N>> { struct Converter<std::array<double, N>> {
optional<std::array<double, N>> operator()(const Convertible& value, Error& error) const; std::optional<std::array<double, N>> operator()(const Convertible& value, Error& error) const;
}; };
template <> template <>
struct Converter<std::vector<std::string>> { struct Converter<std::vector<std::string>> {
optional<std::vector<std::string>> operator()(const Convertible& value, Error& error) const; std::optional<std::vector<std::string>> operator()(const Convertible& value, Error& error) const;
}; };
} // namespace conversion } // namespace conversion

5
include/mbgl/style/conversion/coordinate.hpp
View File

@@ -2,7 +2,8 @@
#include <mbgl/style/conversion.hpp> #include <mbgl/style/conversion.hpp>
#include <mbgl/util/geo.hpp> #include <mbgl/util/geo.hpp>
#include <mbgl/util/optional.hpp>
#include <optional>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
@@ -11,7 +12,7 @@ namespace conversion {
template<> template<>
struct Converter<LatLng> { struct Converter<LatLng> {
public: public:
optional<LatLng> operator() (const Convertible& value, Error& error) const; std::optional<LatLng> operator() (const Convertible& value, Error& error) const;
}; };
} // namespace conversion } // namespace conversion

3
include/mbgl/style/conversion/custom_geometry_source_options.hpp
View File

@@ -2,7 +2,6 @@
#include <mbgl/style/conversion.hpp> #include <mbgl/style/conversion.hpp>
#include <mbgl/style/sources/custom_geometry_source.hpp> #include <mbgl/style/sources/custom_geometry_source.hpp>
#include <mbgl/util/optional.hpp>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
@@ -10,7 +9,7 @@ namespace conversion {
template <> template <>
struct Converter<CustomGeometrySource::Options> { struct Converter<CustomGeometrySource::Options> {
optional<CustomGeometrySource::Options> operator()(const Convertible& value, Error& error) const; std::optional<CustomGeometrySource::Options> operator()(const Convertible& value, Error& error) const;
}; };
} // namespace conversion } // namespace conversion

3
include/mbgl/style/conversion/filter.hpp
View File

@@ -2,7 +2,6 @@
#include <mbgl/style/filter.hpp> #include <mbgl/style/filter.hpp>
#include <mbgl/style/conversion.hpp> #include <mbgl/style/conversion.hpp>
#include <mbgl/util/optional.hpp>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
@@ -11,7 +10,7 @@ namespace conversion {
template <> template <>
struct Converter<Filter> { struct Converter<Filter> {
public: public:
optional<Filter> operator()(const Convertible& value, Error& error) const; std::optional<Filter> operator()(const Convertible& value, Error& error) const;
}; };
} // namespace conversion } // namespace conversion

6
include/mbgl/style/conversion/function.hpp
View File

@@ -6,6 +6,8 @@
#include <mbgl/style/expression/expression.hpp> #include <mbgl/style/expression/expression.hpp>
#include <mbgl/style/expression/value.hpp> #include <mbgl/style/expression/value.hpp>
#include <optional>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
namespace conversion { namespace conversion {
@@ -15,10 +17,10 @@ std::unique_ptr<expression::Expression> convertTokenStringToFormatExpression(con
std::unique_ptr<expression::Expression> convertTokenStringToImageExpression(const std::string&); std::unique_ptr<expression::Expression> convertTokenStringToImageExpression(const std::string&);
std::unique_ptr<expression::Expression> convertTokenStringToExpression(const std::string&); std::unique_ptr<expression::Expression> convertTokenStringToExpression(const std::string&);
optional<std::unique_ptr<expression::Expression>> convertFunctionToExpression(expression::type::Type, const Convertible&, Error&, bool convertTokens); std::optional<std::unique_ptr<expression::Expression>> convertFunctionToExpression(expression::type::Type, const Convertible&, Error&, bool convertTokens);
template <class T> template <class T>
optional<PropertyExpression<T>> convertFunctionToExpression(const Convertible& value, Error& error, bool convertTokens); std::optional<PropertyExpression<T>> convertFunctionToExpression(const Convertible& value, Error& error, bool convertTokens);
} // namespace conversion } // namespace conversion
} // namespace style } // namespace style

7
include/mbgl/style/conversion/geojson.hpp
View File

@@ -2,19 +2,20 @@
#include <mbgl/util/geojson.hpp> #include <mbgl/util/geojson.hpp>
#include <mbgl/style/conversion.hpp> #include <mbgl/style/conversion.hpp>
#include <mbgl/util/optional.hpp>
#include <optional>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
namespace conversion { namespace conversion {
// Workaround until https://github.com/mapbox/mapbox-gl-native/issues/5623 is done. // Workaround until https://github.com/mapbox/mapbox-gl-native/issues/5623 is done.
optional<GeoJSON> parseGeoJSON(const std::string&, Error&); std::optional<GeoJSON> parseGeoJSON(const std::string&, Error&);
template <> template <>
struct Converter<GeoJSON> { struct Converter<GeoJSON> {
public: public:
optional<GeoJSON> operator()(const Convertible&, Error&) const; std::optional<GeoJSON> operator()(const Convertible&, Error&) const;
}; };
} // namespace conversion } // namespace conversion

3
include/mbgl/style/conversion/geojson_options.hpp
View File

@@ -2,7 +2,6 @@
#include <mbgl/style/sources/geojson_source.hpp> #include <mbgl/style/sources/geojson_source.hpp>
#include <mbgl/style/conversion.hpp> #include <mbgl/style/conversion.hpp>
#include <mbgl/util/optional.hpp>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
@@ -10,7 +9,7 @@ namespace conversion {
template <> template <>
struct Converter<GeoJSONOptions> { struct Converter<GeoJSONOptions> {
optional<GeoJSONOptions> operator()(const Convertible& value, Error& error) const; std::optional<GeoJSONOptions> operator()(const Convertible& value, Error& error) const;
}; };
} // namespace conversion } // namespace conversion

6
include/mbgl/style/conversion/layer.hpp
View File

@@ -2,9 +2,9 @@
#include <mbgl/style/layer.hpp> #include <mbgl/style/layer.hpp>
#include <mbgl/style/conversion.hpp> #include <mbgl/style/conversion.hpp>
#include <mbgl/util/optional.hpp>
#include <memory> #include <memory>
#include <optional>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
@@ -13,10 +13,10 @@ namespace conversion {
template <> template <>
struct Converter<std::unique_ptr<Layer>> { struct Converter<std::unique_ptr<Layer>> {
public: public:
optional<std::unique_ptr<Layer>> operator()(const Convertible& value, Error& error) const; std::optional<std::unique_ptr<Layer>> operator()(const Convertible& value, Error& error) const;
}; };
optional<Error> setPaintProperties(Layer& layer, const Convertible& value); std::optional<Error> setPaintProperties(Layer& layer, const Convertible& value);
} // namespace conversion } // namespace conversion
} // namespace style } // namespace style

5
include/mbgl/style/conversion/light.hpp
View File

@@ -2,7 +2,8 @@
#include <mbgl/style/light.hpp> #include <mbgl/style/light.hpp>
#include <mbgl/style/conversion.hpp> #include <mbgl/style/conversion.hpp>
#include <mbgl/util/optional.hpp>
#include <optional>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
@@ -11,7 +12,7 @@ namespace conversion {
template <> template <>
struct Converter<Light> { struct Converter<Light> {
public: public:
optional<Light> operator()(const Convertible& value, Error& error) const; std::optional<Light> operator()(const Convertible& value, Error& error) const;
}; };
} // namespace conversion } // namespace conversion

5
include/mbgl/style/conversion/position.hpp
View File

@@ -2,7 +2,8 @@
#include <mbgl/style/position.hpp> #include <mbgl/style/position.hpp>
#include <mbgl/style/conversion.hpp> #include <mbgl/style/conversion.hpp>
#include <mbgl/util/optional.hpp>
#include <optional>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
@@ -10,7 +11,7 @@ namespace conversion {
template <> template <>
struct Converter<Position> { struct Converter<Position> {
optional<Position> operator()(const Convertible& value, Error& error) const; std::optional<Position> operator()(const Convertible& value, Error& error) const;
}; };
} // namespace conversion } // namespace conversion

6
include/mbgl/style/conversion/property_value.hpp
View File

@@ -10,13 +10,15 @@
#include <mbgl/style/expression/parsing_context.hpp> #include <mbgl/style/expression/parsing_context.hpp>
#include <mbgl/style/expression/literal.hpp> #include <mbgl/style/expression/literal.hpp>
#include <optional>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
namespace conversion { namespace conversion {
template <class T> template <class T>
struct Converter<PropertyValue<T>> { struct Converter<PropertyValue<T>> {
optional<PropertyValue<T>> operator()(const Convertible& value, Error& error, bool allowDataExpressions, bool convertTokens) const; std::optional<PropertyValue<T>> operator()(const Convertible& value, Error& error, bool allowDataExpressions, bool convertTokens) const;
template <class S> template <class S>
PropertyValue<T> maybeConvertTokens(const S& t) const { PropertyValue<T> maybeConvertTokens(const S& t) const {
@@ -49,7 +51,7 @@ struct Converter<PropertyValue<T>> {
template <> template <>
struct Converter<PropertyValue<std::array<double, 3>>, void> { struct Converter<PropertyValue<std::array<double, 3>>, void> {
optional<PropertyValue<std::array<double, 3>>> operator()(const Convertible& value, Error& error, bool, bool) const; std::optional<PropertyValue<std::array<double, 3>>> operator()(const Convertible& value, Error& error, bool, bool) const;
}; };
} // namespace conversion } // namespace conversion
} // namespace style } // namespace style

5
include/mbgl/style/conversion/rotation.hpp
View File

@@ -2,7 +2,8 @@
#include <mbgl/style/conversion.hpp> #include <mbgl/style/conversion.hpp>
#include <mbgl/style/rotation.hpp> #include <mbgl/style/rotation.hpp>
#include <mbgl/util/optional.hpp>
#include <optional>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
@@ -10,7 +11,7 @@ namespace conversion {
template <> template <>
struct Converter<style::Rotation> { struct Converter<style::Rotation> {
optional<style::Rotation> operator()(const Convertible& value, Error& error) const; std::optional<style::Rotation> operator()(const Convertible& value, Error& error) const;
}; };
} // namespace conversion } // namespace conversion

4
include/mbgl/style/conversion/source.hpp
View File

@@ -2,9 +2,9 @@
#include <mbgl/style/source.hpp> #include <mbgl/style/source.hpp>
#include <mbgl/style/conversion.hpp> #include <mbgl/style/conversion.hpp>
#include <mbgl/util/optional.hpp>
#include <memory> #include <memory>
#include <optional>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
@@ -13,7 +13,7 @@ namespace conversion {
template <> template <>
struct Converter<std::unique_ptr<Source>> { struct Converter<std::unique_ptr<Source>> {
public: public:
optional<std::unique_ptr<Source>> operator()(const Convertible& value, Error& error, const std::string& id) const; std::optional<std::unique_ptr<Source>> operator()(const Convertible& value, Error& error, const std::string& id) const;
}; };
} // namespace conversion } // namespace conversion

5
include/mbgl/style/conversion/tileset.hpp
View File

@@ -2,7 +2,8 @@
#include <mbgl/util/tileset.hpp> #include <mbgl/util/tileset.hpp>
#include <mbgl/style/conversion.hpp> #include <mbgl/style/conversion.hpp>
#include <mbgl/util/optional.hpp>
#include <optional>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
@@ -11,7 +12,7 @@ namespace conversion {
template <> template <>
struct Converter<Tileset> { struct Converter<Tileset> {
public: public:
optional<Tileset> operator()(const Convertible& value, Error& error) const; std::optional<Tileset> operator()(const Convertible& value, Error& error) const;
}; };
} // namespace conversion } // namespace conversion

5
include/mbgl/style/conversion/transition_options.hpp
View File

@@ -2,7 +2,8 @@
#include <mbgl/style/transition_options.hpp> #include <mbgl/style/transition_options.hpp>
#include <mbgl/style/conversion.hpp> #include <mbgl/style/conversion.hpp>
#include <mbgl/util/optional.hpp>
#include <optional>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
@@ -11,7 +12,7 @@ namespace conversion {
template <> template <>
struct Converter<TransitionOptions> { struct Converter<TransitionOptions> {
public: public:
optional<TransitionOptions> operator()(const Convertible& value, Error& error) const; std::optional<TransitionOptions> operator()(const Convertible& value, Error& error) const;
}; };
} // namespace conversion } // namespace conversion

48
include/mbgl/style/conversion_impl.hpp
View File

@@ -9,7 +9,6 @@
#include <mbgl/style/transition_options.hpp> #include <mbgl/style/transition_options.hpp>
#include <mbgl/util/feature.hpp> #include <mbgl/util/feature.hpp>
#include <mbgl/util/geojson.hpp> #include <mbgl/util/geojson.hpp>
#include <mbgl/util/optional.hpp>
#include <mbgl/util/traits.hpp> #include <mbgl/util/traits.hpp>
#include <mapbox/compatibility/value.hpp> #include <mapbox/compatibility/value.hpp>
@@ -18,6 +17,7 @@
#include <chrono> #include <chrono>
#include <string> #include <string>
#include <type_traits> #include <type_traits>
#include <optional>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
@@ -34,7 +34,7 @@ namespace style {
A single template function serves as the public interface: A single template function serves as the public interface:
template <class T> template <class T>
optional<T> convert(const Convertible& input, Error& error); std::optional<T> convert(const Convertible& input, Error& error);
Where `T` is one of the above types. If the conversion fails, the result is empty, and the Where `T` is one of the above types. If the conversion fails, the result is empty, and the
error parameter includes diagnostic text suitable for presentation to a library user. Otherwise, error parameter includes diagnostic text suitable for presentation to a library user. Otherwise,
@@ -69,7 +69,7 @@ namespace style {
* `objectMember(v, name)` -- called only if `isObject(v)`; `name` is `const char *`; return value: * `objectMember(v, name)` -- called only if `isObject(v)`; `name` is `const char *`; return value:
* is true when evaluated in a boolean context iff the named member exists * is true when evaluated in a boolean context iff the named member exists
* is convertable to a `V` or `V&` when dereferenced * is convertable to a `V` or `V&` when dereferenced
* `eachMember(v, [] (const std::string&, const V&) -> optional<Error> {...})` -- called * `eachMember(v, [] (const std::string&, const V&) -> std::optional<Error> {...})` -- called
only if `isObject(v)`; calls the provided lambda once for each key and value of the object; only if `isObject(v)`; calls the provided lambda once for each key and value of the object;
short-circuits if any call returns an `Error` short-circuits if any call returns an `Error`
@@ -150,42 +150,42 @@ public:
return v.vtable->isObject(v.storage); return v.vtable->isObject(v.storage);
} }
friend inline optional<Convertible> objectMember(const Convertible& v, const char * name) { friend inline std::optional<Convertible> objectMember(const Convertible& v, const char * name) {
assert(v.vtable); assert(v.vtable);
return v.vtable->objectMember(v.storage, name); return v.vtable->objectMember(v.storage, name);
} }
friend inline optional<Error> eachMember(const Convertible& v, const std::function<optional<Error> (const std::string&, const Convertible&)>& fn) { friend inline std::optional<Error> eachMember(const Convertible& v, const std::function<std::optional<Error> (const std::string&, const Convertible&)>& fn) {
assert(v.vtable); assert(v.vtable);
return v.vtable->eachMember(v.storage, fn); return v.vtable->eachMember(v.storage, fn);
} }
friend inline optional<bool> toBool(const Convertible& v) { friend inline std::optional<bool> toBool(const Convertible& v) {
assert(v.vtable); assert(v.vtable);
return v.vtable->toBool(v.storage); return v.vtable->toBool(v.storage);
} }
friend inline optional<float> toNumber(const Convertible& v) { friend inline std::optional<float> toNumber(const Convertible& v) {
assert(v.vtable); assert(v.vtable);
return v.vtable->toNumber(v.storage); return v.vtable->toNumber(v.storage);
} }
friend inline optional<double> toDouble(const Convertible& v) { friend inline std::optional<double> toDouble(const Convertible& v) {
assert(v.vtable); assert(v.vtable);
return v.vtable->toDouble(v.storage); return v.vtable->toDouble(v.storage);
} }
friend inline optional<std::string> toString(const Convertible& v) { friend inline std::optional<std::string> toString(const Convertible& v) {
assert(v.vtable); assert(v.vtable);
return v.vtable->toString(v.storage); return v.vtable->toString(v.storage);
} }
friend inline optional<Value> toValue(const Convertible& v) { friend inline std::optional<Value> toValue(const Convertible& v) {
assert(v.vtable); assert(v.vtable);
return v.vtable->toValue(v.storage); return v.vtable->toValue(v.storage);
} }
friend inline optional<GeoJSON> toGeoJSON(const Convertible& v, Error& error) { friend inline std::optional<GeoJSON> toGeoJSON(const Convertible& v, Error& error) {
assert(v.vtable); assert(v.vtable);
return v.vtable->toGeoJSON(v.storage, error); return v.vtable->toGeoJSON(v.storage, error);
} }
@@ -214,23 +214,23 @@ private:
Convertible (*arrayMember) (const Storage&, std::size_t); Convertible (*arrayMember) (const Storage&, std::size_t);
bool (*isObject) (const Storage&); bool (*isObject) (const Storage&);
optional<Convertible> (*objectMember) (const Storage&, const char *); std::optional<Convertible> (*objectMember) (const Storage&, const char *);
optional<Error> (*eachMember) (const Storage&, const std::function<optional<Error> (const std::string&, const Convertible&)>&); std::optional<Error> (*eachMember) (const Storage&, const std::function<std::optional<Error> (const std::string&, const Convertible&)>&);
optional<bool> (*toBool) (const Storage&); std::optional<bool> (*toBool) (const Storage&);
optional<float> (*toNumber) (const Storage&); std::optional<float> (*toNumber) (const Storage&);
optional<double> (*toDouble) (const Storage&); std::optional<double> (*toDouble) (const Storage&);
optional<std::string> (*toString) (const Storage&); std::optional<std::string> (*toString) (const Storage&);
optional<Value> (*toValue) (const Storage&); std::optional<Value> (*toValue) (const Storage&);
// https://github.com/mapbox/mapbox-gl-native/issues/5623 // https://github.com/mapbox/mapbox-gl-native/issues/5623
optional<GeoJSON> (*toGeoJSON) (const Storage&, Error&); std::optional<GeoJSON> (*toGeoJSON) (const Storage&, Error&);
}; };
// Extracted this function from the table below to work around a GCC bug with differing // Extracted this function from the table below to work around a GCC bug with differing
// visibility settings for capturing lambdas: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80947 // visibility settings for capturing lambdas: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80947
template <typename T> template <typename T>
static auto vtableEachMember(const Storage& s, const std::function<optional<Error>(const std::string&, const Convertible&)>& fn) { static auto vtableEachMember(const Storage& s, const std::function<std::optional<Error>(const std::string&, const Convertible&)>& fn) {
return ConversionTraits<T>::eachMember(reinterpret_cast<const T&>(s), [&](const std::string& k, T&& v) { return ConversionTraits<T>::eachMember(reinterpret_cast<const T&>(s), [&](const std::string& k, T&& v) {
return fn(k, Convertible(std::move(v))); return fn(k, Convertible(std::move(v)));
}); });
@@ -262,11 +262,11 @@ private:
return Traits::isObject(reinterpret_cast<const T&>(s)); return Traits::isObject(reinterpret_cast<const T&>(s));
}, },
[] (const Storage& s, const char * key) { [] (const Storage& s, const char * key) {
optional<T> member = Traits::objectMember(reinterpret_cast<const T&>(s), key); std::optional<T> member = Traits::objectMember(reinterpret_cast<const T&>(s), key);
if (member) { if (member) {
return optional<Convertible>(Convertible(std::move(*member))); return std::optional<Convertible>(Convertible(std::move(*member)));
} else { } else {
return optional<Convertible>(); return std::optional<Convertible>();
} }
}, },
vtableEachMember<T>, vtableEachMember<T>,
@@ -297,7 +297,7 @@ private:
}; };
template <class T, class...Args> template <class T, class...Args>
optional<T> convert(const Convertible& value, Error& error, Args&&...args) { std::optional<T> convert(const Convertible& value, Error& error, Args&&...args) {
return Converter<T>()(value, error, std::forward<Args>(args)...); return Converter<T>()(value, error, std::forward<Args>(args)...);
} }

2
include/mbgl/style/expression/assertion.hpp
View File

@@ -22,7 +22,7 @@ public:
bool operator==(const Expression& e) const override; bool operator==(const Expression& e) const override;
std::vector<optional<Value>> possibleOutputs() const override; std::vector<std::optional<Value>> possibleOutputs() const override;
mbgl::Value serialize() const override; mbgl::Value serialize() const override;
std::string getOperator() const override; std::string getOperator() const override;

4
include/mbgl/style/expression/at.hpp
View File

@@ -29,8 +29,8 @@ public:
return false; return false;
} }
std::vector<optional<Value>> possibleOutputs() const override { std::vector<std::optional<Value>> possibleOutputs() const override {
return { nullopt }; return { std::nullopt };
} }
std::string getOperator() const override { return "at"; } std::string getOperator() const override { return "at"; }

4
include/mbgl/style/expression/boolean_operator.hpp
View File

@@ -21,7 +21,7 @@ public:
EvaluationResult evaluate(const EvaluationContext& params) const override; EvaluationResult evaluate(const EvaluationContext& params) const override;
void eachChild(const std::function<void(const Expression&)>& visit) const override; void eachChild(const std::function<void(const Expression&)>& visit) const override;
bool operator==(const Expression& e) const override; bool operator==(const Expression& e) const override;
std::vector<optional<Value>> possibleOutputs() const override; std::vector<std::optional<Value>> possibleOutputs() const override;
std::string getOperator() const override { return "any"; } std::string getOperator() const override { return "any"; }
private: private:
@@ -40,7 +40,7 @@ public:
EvaluationResult evaluate(const EvaluationContext& params) const override; EvaluationResult evaluate(const EvaluationContext& params) const override;
void eachChild(const std::function<void(const Expression&)>& visit) const override; void eachChild(const std::function<void(const Expression&)>& visit) const override;
bool operator==(const Expression& e) const override; bool operator==(const Expression& e) const override;
std::vector<optional<Value>> possibleOutputs() const override; std::vector<std::optional<Value>> possibleOutputs() const override;
std::string getOperator() const override { return "all"; } std::string getOperator() const override { return "all"; }
private: private:

2
include/mbgl/style/expression/case.hpp
View File

@@ -26,7 +26,7 @@ public:
bool operator==(const Expression& e) const override; bool operator==(const Expression& e) const override;
std::vector<optional<Value>> possibleOutputs() const override; std::vector<std::optional<Value>> possibleOutputs() const override;
std::string getOperator() const override { return "case"; } std::string getOperator() const override { return "case"; }
private: private:

3
include/mbgl/style/expression/check_subtype.hpp
View File

@@ -1,7 +1,6 @@
#pragma once #pragma once
#include <mbgl/style/expression/type.hpp> #include <mbgl/style/expression/type.hpp>
#include <mbgl/util/optional.hpp>
#include <memory> #include <memory>
namespace mbgl { namespace mbgl {
@@ -9,7 +8,7 @@ namespace style {
namespace expression { namespace expression {
namespace type { namespace type {
optional<std::string> checkSubtype(const Type& expected, const Type& t); std::optional<std::string> checkSubtype(const Type& expected, const Type& t);
} // namespace type } // namespace type
} // namespace expression } // namespace expression

2
include/mbgl/style/expression/coalesce.hpp
View File

@@ -28,7 +28,7 @@ public:
bool operator==(const Expression& e) const override; bool operator==(const Expression& e) const override;
std::vector<optional<Value>> possibleOutputs() const override; std::vector<std::optional<Value>> possibleOutputs() const override;
std::size_t getLength() const { std::size_t getLength() const {
return args.size(); return args.size();

2
include/mbgl/style/expression/coercion.hpp
View File

@@ -23,7 +23,7 @@ public:
bool operator==(const Expression& e) const override; bool operator==(const Expression& e) const override;
std::vector<optional<Value>> possibleOutputs() const override; std::vector<std::optional<Value>> possibleOutputs() const override;
std::string getOperator() const override; std::string getOperator() const override;
private: private:

4
include/mbgl/style/expression/collator.hpp
View File

@@ -1,9 +1,9 @@
#pragma once #pragma once
#include <mbgl/i18n/collator.hpp> #include <mbgl/i18n/collator.hpp>
#include <mbgl/util/optional.hpp>
#include <string> #include <string>
#include <optional>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
@@ -11,7 +11,7 @@ namespace expression {
class Collator { class Collator {
public: public:
Collator(bool caseSensitive, bool diacriticSensitive, const optional<std::string>& locale = {}); Collator(bool caseSensitive, bool diacriticSensitive, const std::optional<std::string>& locale = std::nullopt);
bool operator==(const Collator& other) const; bool operator==(const Collator& other) const;

8
include/mbgl/style/expression/collator_expression.hpp
View File

@@ -14,7 +14,7 @@ class CollatorExpression : public Expression {
public: public:
CollatorExpression(std::unique_ptr<Expression> caseSensitive, CollatorExpression(std::unique_ptr<Expression> caseSensitive,
std::unique_ptr<Expression> diacriticSensitive, std::unique_ptr<Expression> diacriticSensitive,
optional<std::unique_ptr<Expression>> locale); std::optional<std::unique_ptr<Expression>> locale);
EvaluationResult evaluate(const EvaluationContext&) const override; EvaluationResult evaluate(const EvaluationContext&) const override;
static ParseResult parse(const mbgl::style::conversion::Convertible&, ParsingContext&); static ParseResult parse(const mbgl::style::conversion::Convertible&, ParsingContext&);
@@ -23,12 +23,12 @@ public:
bool operator==(const Expression& e) const override; bool operator==(const Expression& e) const override;
std::vector<optional<Value>> possibleOutputs() const override { std::vector<std::optional<Value>> possibleOutputs() const override {
// Technically the set of possible outputs is the combinatoric set of Collators produced // Technically the set of possible outputs is the combinatoric set of Collators produced
// by all possibleOutputs of locale/caseSensitive/diacriticSensitive // by all possibleOutputs of locale/caseSensitive/diacriticSensitive
// But for the primary use of Collators in comparison operators, we ignore the Collator's // But for the primary use of Collators in comparison operators, we ignore the Collator's
// possibleOutputs anyway, so we can get away with leaving this undefined for now. // possibleOutputs anyway, so we can get away with leaving this undefined for now.
return { nullopt }; return { std::nullopt };
} }
mbgl::Value serialize() const override; mbgl::Value serialize() const override;
@@ -36,7 +36,7 @@ public:
private: private:
std::unique_ptr<Expression> caseSensitive; std::unique_ptr<Expression> caseSensitive;
std::unique_ptr<Expression> diacriticSensitive; std::unique_ptr<Expression> diacriticSensitive;
optional<std::unique_ptr<Expression>> locale; std::optional<std::unique_ptr<Expression>> locale;
}; };
} // namespace expression } // namespace expression

4
include/mbgl/style/expression/comparison.hpp
View File

@@ -25,7 +25,7 @@ public:
void eachChild(const std::function<void(const Expression&)>& visit) const override; void eachChild(const std::function<void(const Expression&)>& visit) const override;
bool operator==(const Expression&) const override; bool operator==(const Expression&) const override;
EvaluationResult evaluate(const EvaluationContext&) const override; EvaluationResult evaluate(const EvaluationContext&) const override;
std::vector<optional<Value>> possibleOutputs() const override; std::vector<std::optional<Value>> possibleOutputs() const override;
std::string getOperator() const override; std::string getOperator() const override;
private: private:
@@ -49,7 +49,7 @@ public:
void eachChild(const std::function<void(const Expression&)>& visit) const override; void eachChild(const std::function<void(const Expression&)>& visit) const override;
bool operator==(const Expression&) const override; bool operator==(const Expression&) const override;
EvaluationResult evaluate(const EvaluationContext&) const override; EvaluationResult evaluate(const EvaluationContext&) const override;
std::vector<optional<Value>> possibleOutputs() const override; std::vector<std::optional<Value>> possibleOutputs() const override;
std::string getOperator() const override; std::string getOperator() const override;
private: private:

6
include/mbgl/style/expression/compound_expression.hpp
View File

@@ -5,10 +5,10 @@
#include <mbgl/style/expression/type.hpp> #include <mbgl/style/expression/type.hpp>
#include <mbgl/style/expression/value.hpp> #include <mbgl/style/expression/value.hpp>
#include <mbgl/style/conversion.hpp> #include <mbgl/style/conversion.hpp>
#include <mbgl/util/optional.hpp>
#include <memory> #include <memory>
#include <vector> #include <vector>
#include <optional>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
@@ -33,11 +33,11 @@ public:
std::string getOperator() const override; std::string getOperator() const override;
EvaluationResult evaluate(const EvaluationContext& evaluationParams) const override; EvaluationResult evaluate(const EvaluationContext& evaluationParams) const override;
std::vector<optional<Value>> possibleOutputs() const override; std::vector<std::optional<Value>> possibleOutputs() const override;
void eachChild(const std::function<void(const Expression&)>& visit) const override; void eachChild(const std::function<void(const Expression&)>& visit) const override;
bool operator==(const Expression& e) const override; bool operator==(const Expression& e) const override;
optional<std::size_t> getParameterCount() const; std::optional<std::size_t> getParameterCount() const;
static bool exists(const std::string& name); static bool exists(const std::string& name);

2
include/mbgl/style/expression/distance.hpp
View File

@@ -33,7 +33,7 @@ public:
bool operator==(const Expression& e) const override; bool operator==(const Expression& e) const override;
std::vector<optional<Value>> possibleOutputs() const override; std::vector<std::optional<Value>> possibleOutputs() const override;
mbgl::Value serialize() const override; mbgl::Value serialize() const override;
std::string getOperator() const override; std::string getOperator() const override;

2
include/mbgl/style/expression/error.hpp
View File

@@ -24,7 +24,7 @@ public:
return EvaluationError{message}; return EvaluationError{message};
} }
std::vector<optional<Value>> possibleOutputs() const override { std::vector<std::optional<Value>> possibleOutputs() const override {
return {}; return {};
} }

26
include/mbgl/style/expression/expression.hpp
View File

@@ -5,12 +5,12 @@
#include <mbgl/style/expression/value.hpp> #include <mbgl/style/expression/value.hpp>
#include <mbgl/tile/tile_id.hpp> #include <mbgl/tile/tile_id.hpp>
#include <mbgl/util/color.hpp> #include <mbgl/util/color.hpp>
#include <mbgl/util/optional.hpp>
#include <mbgl/util/variant.hpp> #include <mbgl/util/variant.hpp>
#include <array> #include <array>
#include <vector> #include <vector>
#include <memory> #include <memory>
#include <optional>
namespace mbgl { namespace mbgl {
@@ -30,12 +30,12 @@ public:
explicit EvaluationContext(float zoom_) : zoom(zoom_) {} explicit EvaluationContext(float zoom_) : zoom(zoom_) {}
explicit EvaluationContext(GeometryTileFeature const * feature_) : feature(feature_) {} explicit EvaluationContext(GeometryTileFeature const * feature_) : feature(feature_) {}
EvaluationContext(float zoom_, GeometryTileFeature const* feature_) : zoom(zoom_), feature(feature_) {} EvaluationContext(float zoom_, GeometryTileFeature const* feature_) : zoom(zoom_), feature(feature_) {}
EvaluationContext(optional<mbgl::Value> accumulated_, GeometryTileFeature const * feature_) : EvaluationContext(std::optional<mbgl::Value> accumulated_, GeometryTileFeature const * feature_) :
accumulated(std::move(accumulated_)), feature(feature_) accumulated(std::move(accumulated_)), feature(feature_)
{} {}
EvaluationContext(float zoom_, GeometryTileFeature const* feature_, const FeatureState* state_) EvaluationContext(float zoom_, GeometryTileFeature const* feature_, const FeatureState* state_)
: zoom(zoom_), feature(feature_), featureState(state_) {} : zoom(zoom_), feature(feature_), featureState(state_) {}
EvaluationContext(optional<float> zoom_, GeometryTileFeature const * feature_, optional<double> colorRampParameter_) : EvaluationContext(std::optional<float> zoom_, GeometryTileFeature const * feature_, std::optional<double> colorRampParameter_) :
zoom(std::move(zoom_)), feature(feature_), colorRampParameter(std::move(colorRampParameter_)) zoom(std::move(zoom_)), feature(feature_), colorRampParameter(std::move(colorRampParameter_))
{} {}
@@ -59,10 +59,10 @@ public:
return *this; return *this;
}; };
optional<float> zoom; std::optional<float> zoom;
optional<mbgl::Value> accumulated; std::optional<mbgl::Value> accumulated;
GeometryTileFeature const* feature = nullptr; GeometryTileFeature const* feature = nullptr;
optional<double> colorRampParameter; std::optional<double> colorRampParameter;
// Contains formatted section object, std::unordered_map<std::string, Value>. // Contains formatted section object, std::unordered_map<std::string, Value>.
const Value* formattedSection = nullptr; const Value* formattedSection = nullptr;
const FeatureState* featureState = nullptr; const FeatureState* featureState = nullptr;
@@ -191,24 +191,24 @@ public:
Kind getKind() const { return kind; }; Kind getKind() const { return kind; };
type::Type getType() const { return type; }; type::Type getType() const { return type; };
EvaluationResult evaluate(optional<float> zoom, const Feature& feature, optional<double> colorRampParameter) const; EvaluationResult evaluate(std::optional<float> zoom, const Feature& feature, std::optional<double> colorRampParameter) const;
EvaluationResult evaluate(optional<float> zoom, EvaluationResult evaluate(std::optional<float> zoom,
const Feature& feature, const Feature& feature,
optional<double> colorRampParameter, std::optional<double> colorRampParameter,
const std::set<std::string>& availableImages) const; const std::set<std::string>& availableImages) const;
EvaluationResult evaluate(optional<float> zoom, EvaluationResult evaluate(std::optional<float> zoom,
const Feature& feature, const Feature& feature,
optional<double> colorRampParameter, std::optional<double> colorRampParameter,
const std::set<std::string>& availableImages, const std::set<std::string>& availableImages,
const CanonicalTileID& canonical) const; const CanonicalTileID& canonical) const;
EvaluationResult evaluate(optional<mbgl::Value> accumulated, const Feature& feature) const; EvaluationResult evaluate(std::optional<mbgl::Value> accumulated, const Feature& feature) const;
/** /**
* Statically analyze the expression, attempting to enumerate possible outputs. Returns * Statically analyze the expression, attempting to enumerate possible outputs. Returns
* an array of values plus the sentinel null optional value, used to indicate that the * an array of values plus the sentinel null optional value, used to indicate that the
* complete set of outputs is statically undecidable. * complete set of outputs is statically undecidable.
*/ */
virtual std::vector<optional<Value>> possibleOutputs() const = 0; virtual std::vector<std::optional<Value>> possibleOutputs() const = 0;
virtual mbgl::Value serialize() const { virtual mbgl::Value serialize() const {
std::vector<mbgl::Value> serialized; std::vector<mbgl::Value> serialized;

5
include/mbgl/style/expression/find_zoom_curve.hpp
View File

@@ -5,13 +5,14 @@
#include <mbgl/style/expression/step.hpp> #include <mbgl/style/expression/step.hpp>
#include <mbgl/util/variant.hpp> #include <mbgl/util/variant.hpp>
#include <mbgl/util/optional.hpp>
#include <optional>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
namespace expression { namespace expression {
optional<variant<const Interpolate*, const Step*, ParsingError>> findZoomCurve(const expression::Expression* e); std::optional<variant<const Interpolate*, const Step*, ParsingError>> findZoomCurve(const expression::Expression* e);
variant<std::nullptr_t, const Interpolate*, const Step*> findZoomCurveChecked(const expression::Expression* e); variant<std::nullptr_t, const Interpolate*, const Step*> findZoomCurveChecked(const expression::Expression* e);

16
include/mbgl/style/expression/format_expression.hpp
View File

@@ -10,17 +10,17 @@ namespace expression {
struct FormatExpressionSection { struct FormatExpressionSection {
explicit FormatExpressionSection(std::unique_ptr<Expression> content_); explicit FormatExpressionSection(std::unique_ptr<Expression> content_);
void setTextSectionOptions(optional<std::unique_ptr<Expression>> fontScale_, void setTextSectionOptions(std::optional<std::unique_ptr<Expression>> fontScale_,
optional<std::unique_ptr<Expression>> textFont_, std::optional<std::unique_ptr<Expression>> textFont_,
optional<std::unique_ptr<Expression>> textColor_); std::optional<std::unique_ptr<Expression>> textColor_);
// Content can be expression that evaluates to String or Image. // Content can be expression that evaluates to String or Image.
std::shared_ptr<Expression> content; std::shared_ptr<Expression> content;
// Text related section options. // Text related section options.
optional<std::shared_ptr<Expression>> fontScale; std::optional<std::shared_ptr<Expression>> fontScale;
optional<std::shared_ptr<Expression>> textFont; std::optional<std::shared_ptr<Expression>> textFont;
optional<std::shared_ptr<Expression>> textColor; std::optional<std::shared_ptr<Expression>> textColor;
}; };
class FormatExpression final : public Expression { class FormatExpression final : public Expression {
@@ -34,10 +34,10 @@ public:
bool operator==(const Expression& e) const override; bool operator==(const Expression& e) const override;
std::vector<optional<Value>> possibleOutputs() const override { std::vector<std::optional<Value>> possibleOutputs() const override {
// Technically the combinatoric set of all children // Technically the combinatoric set of all children
// Usually, this.text will be undefined anyway // Usually, this.text will be undefined anyway
return { nullopt }; return { std::nullopt };
} }
const std::vector<FormatExpressionSection>& getSections() const { return sections; } const std::vector<FormatExpressionSection>& getSections() const { return sections; }

4
include/mbgl/style/expression/format_section_override.hpp
View File

@@ -70,8 +70,8 @@ public:
return false; return false;
} }
std::vector<optional<Value>> possibleOutputs() const final { std::vector<std::optional<Value>> possibleOutputs() const final {
return {nullopt}; return {std::nullopt};
} }
std::string getOperator() const final { return "format-section-override"; } std::string getOperator() const final { return "format-section-override"; }

20
include/mbgl/style/expression/formatted.hpp
View File

@@ -4,10 +4,10 @@
#include <mbgl/style/expression/image.hpp> #include <mbgl/style/expression/image.hpp>
#include <mbgl/util/color.hpp> #include <mbgl/util/color.hpp>
#include <mbgl/util/font_stack.hpp> #include <mbgl/util/font_stack.hpp>
#include <mbgl/util/optional.hpp>
#include <vector> #include <vector>
#include <string> #include <string>
#include <optional>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
@@ -19,9 +19,9 @@ extern const char* const kFormattedSectionTextColor;
struct FormattedSection { struct FormattedSection {
explicit FormattedSection(std::string text_, explicit FormattedSection(std::string text_,
optional<double> fontScale_, std::optional<double> fontScale_,
optional<FontStack> fontStack_, std::optional<FontStack> fontStack_,
optional<Color> textColor_) std::optional<Color> textColor_)
: text(std::move(text_)), : text(std::move(text_)),
fontScale(std::move(fontScale_)), fontScale(std::move(fontScale_)),
fontStack(std::move(fontStack_)), fontStack(std::move(fontStack_)),
@@ -30,10 +30,10 @@ struct FormattedSection {
explicit FormattedSection(Image image_) : image(std::move(image_)) {} explicit FormattedSection(Image image_) : image(std::move(image_)) {}
std::string text; std::string text;
optional<Image> image; std::optional<Image> image;
optional<double> fontScale; std::optional<double> fontScale;
optional<FontStack> fontStack; std::optional<FontStack> fontStack;
optional<Color> textColor; std::optional<Color> textColor;
}; };
class Formatted { class Formatted {
@@ -41,7 +41,7 @@ public:
Formatted() = default; Formatted() = default;
Formatted(const char* plainU8String) { Formatted(const char* plainU8String) {
sections.emplace_back(std::string(plainU8String), nullopt, nullopt, nullopt); sections.emplace_back(std::string(plainU8String), std::nullopt, std::nullopt, std::nullopt);
} }
Formatted(std::vector<FormattedSection> sections_) Formatted(std::vector<FormattedSection> sections_)
@@ -65,7 +65,7 @@ namespace conversion {
template <> template <>
struct Converter<expression::Formatted> { struct Converter<expression::Formatted> {
public: public:
optional<expression::Formatted> operator()(const Convertible& value, Error& error) const; std::optional<expression::Formatted> operator()(const Convertible& value, Error& error) const;
}; };
template <> template <>

4
include/mbgl/style/expression/image.hpp
View File

@@ -2,10 +2,10 @@
#include <mbgl/style/conversion.hpp> #include <mbgl/style/conversion.hpp>
#include <mbgl/util/color.hpp> #include <mbgl/util/color.hpp>
#include <mbgl/util/optional.hpp>
#include <string> #include <string>
#include <vector> #include <vector>
#include <optional>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
@@ -35,7 +35,7 @@ namespace conversion {
template <> template <>
struct Converter<expression::Image> { struct Converter<expression::Image> {
public: public:
optional<expression::Image> operator()(const Convertible& value, Error& error) const; std::optional<expression::Image> operator()(const Convertible& value, Error& error) const;
}; };
template <> template <>

2
include/mbgl/style/expression/image_expression.hpp
View File

@@ -19,7 +19,7 @@ public:
bool operator==(const Expression& e) const override; bool operator==(const Expression& e) const override;
std::vector<optional<Value>> possibleOutputs() const override { return {nullopt}; } std::vector<std::optional<Value>> possibleOutputs() const override { return {std::nullopt}; }
mbgl::Value serialize() const override; mbgl::Value serialize() const override;
std::string getOperator() const override { return "image"; } std::string getOperator() const override { return "image"; }

2
include/mbgl/style/expression/in.hpp
View File

@@ -19,7 +19,7 @@ public:
bool operator==(const Expression& e) const override; bool operator==(const Expression& e) const override;
std::vector<optional<Value>> possibleOutputs() const override; std::vector<std::optional<Value>> possibleOutputs() const override;
std::string getOperator() const override; std::string getOperator() const override;

3
include/mbgl/style/expression/interpolate.hpp
View File

@@ -9,6 +9,7 @@
#include <memory> #include <memory>
#include <map> #include <map>
#include <cmath> #include <cmath>
#include <optional>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
@@ -65,7 +66,7 @@ public:
return false; return false;
} }
std::vector<optional<Value>> possibleOutputs() const override; std::vector<std::optional<Value>> possibleOutputs() const override;
mbgl::Value serialize() const override; mbgl::Value serialize() const override;
std::string getOperator() const override { return "interpolate"; } std::string getOperator() const override { return "interpolate"; }

2
include/mbgl/style/expression/length.hpp
View File

@@ -20,7 +20,7 @@ public:
EvaluationResult evaluate(const EvaluationContext& params) const override; EvaluationResult evaluate(const EvaluationContext& params) const override;
void eachChild(const std::function<void(const Expression&)>& visit) const override; void eachChild(const std::function<void(const Expression&)>& visit) const override;
bool operator==(const Expression& e) const override; bool operator==(const Expression& e) const override;
std::vector<optional<Value>> possibleOutputs() const override; std::vector<std::optional<Value>> possibleOutputs() const override;
std::string getOperator() const override { return "length"; } std::string getOperator() const override { return "length"; }
private: private:

5
include/mbgl/style/expression/let.hpp
View File

@@ -6,6 +6,7 @@
#include <memory> #include <memory>
#include <map> #include <map>
#include <optional>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
@@ -34,7 +35,7 @@ public:
return false; return false;
} }
std::vector<optional<Value>> possibleOutputs() const override; std::vector<std::optional<Value>> possibleOutputs() const override;
Expression* getResult() const { Expression* getResult() const {
return result.get(); return result.get();
@@ -65,7 +66,7 @@ public:
return false; return false;
} }
std::vector<optional<Value>> possibleOutputs() const override; std::vector<std::optional<Value>> possibleOutputs() const override;
mbgl::Value serialize() const override; mbgl::Value serialize() const override;
std::string getOperator() const override { return "var"; } std::string getOperator() const override { return "var"; }

2
include/mbgl/style/expression/literal.hpp
View File

@@ -33,7 +33,7 @@ public:
return false; return false;
} }
std::vector<optional<Value>> possibleOutputs() const override { std::vector<std::optional<Value>> possibleOutputs() const override {
return {{ value }}; return {{ value }};
} }

2
include/mbgl/style/expression/match.hpp
View File

@@ -30,7 +30,7 @@ public:
bool operator==(const Expression& e) const override; bool operator==(const Expression& e) const override;
std::vector<optional<Value>> possibleOutputs() const override; std::vector<std::optional<Value>> possibleOutputs() const override;
mbgl::Value serialize() const override; mbgl::Value serialize() const override;
std::string getOperator() const override { return "match"; } std::string getOperator() const override { return "match"; }

2
include/mbgl/style/expression/number_format.hpp
View File

@@ -22,7 +22,7 @@ public:
EvaluationResult evaluate(const EvaluationContext& params) const override; EvaluationResult evaluate(const EvaluationContext& params) const override;
void eachChild(const std::function<void(const Expression&)>& visit) const override; void eachChild(const std::function<void(const Expression&)>& visit) const override;
bool operator==(const Expression& e) const override; bool operator==(const Expression& e) const override;
std::vector<optional<Value>> possibleOutputs() const override; std::vector<std::optional<Value>> possibleOutputs() const override;
mbgl::Value serialize() const override; mbgl::Value serialize() const override;
std::string getOperator() const override { return "number-format"; } std::string getOperator() const override { return "number-format"; }

30
include/mbgl/style/expression/parsing_context.hpp
View File

@@ -1,6 +1,5 @@
#pragma once #pragma once
#include <mbgl/util/optional.hpp>
#include <mbgl/util/string.hpp> #include <mbgl/util/string.hpp>
#include <mbgl/style/expression/type.hpp> #include <mbgl/style/expression/type.hpp>
#include <mbgl/style/conversion.hpp> #include <mbgl/style/conversion.hpp>
@@ -12,6 +11,7 @@
#include <unordered_map> #include <unordered_map>
#include <utility> #include <utility>
#include <vector> #include <vector>
#include <optional>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
@@ -25,7 +25,7 @@ struct ParsingError {
bool operator==(const ParsingError& rhs) const { return message == rhs.message && key == rhs.key; } bool operator==(const ParsingError& rhs) const { return message == rhs.message && key == rhs.key; }
}; };
using ParseResult = optional<std::unique_ptr<Expression>>; using ParseResult = std::optional<std::unique_ptr<Expression>>;
namespace detail { namespace detail {
@@ -39,14 +39,14 @@ public:
const std::map<std::string, std::shared_ptr<Expression>>& bindings; const std::map<std::string, std::shared_ptr<Expression>>& bindings;
std::shared_ptr<Scope> parent; std::shared_ptr<Scope> parent;
optional<std::shared_ptr<Expression>> get(const std::string& name) { std::optional<std::shared_ptr<Expression>> get(const std::string& name) {
auto it = bindings.find(name); auto it = bindings.find(name);
if (it != bindings.end()) { if (it != bindings.end()) {
return {it->second}; return {it->second};
} else if (parent) { } else if (parent) {
return parent->get(name); return parent->get(name);
} else { } else {
return optional<std::shared_ptr<Expression>>(); return std::optional<std::shared_ptr<Expression>>();
} }
} }
}; };
@@ -86,7 +86,7 @@ public:
ParsingContext& operator=(const ParsingContext&) = delete; ParsingContext& operator=(const ParsingContext&) = delete;
std::string getKey() const { return key; } std::string getKey() const { return key; }
optional<type::Type> getExpected() const { return expected; } std::optional<type::Type> getExpected() const { return expected; }
const std::vector<ParsingError>& getErrors() const { return *errors; } const std::vector<ParsingError>& getErrors() const { return *errors; }
std::string getCombinedErrors() const; std::string getCombinedErrors() const;
@@ -94,7 +94,7 @@ public:
Parse the given style-spec JSON value as an expression. Parse the given style-spec JSON value as an expression.
*/ */
ParseResult parseExpression(const mbgl::style::conversion::Convertible& value, ParseResult parseExpression(const mbgl::style::conversion::Convertible& value,
const optional<TypeAnnotationOption>& = {}); const std::optional<TypeAnnotationOption>& = std::nullopt);
/** /**
Parse the given style-spec JSON value as an expression intended to be used Parse the given style-spec JSON value as an expression intended to be used
@@ -108,24 +108,24 @@ public:
*/ */
ParseResult parse(const mbgl::style::conversion::Convertible&, ParseResult parse(const mbgl::style::conversion::Convertible&,
std::size_t, std::size_t,
optional<type::Type> = {}, std::optional<type::Type> = std::nullopt,
const optional<TypeAnnotationOption>& = {}); const std::optional<TypeAnnotationOption>& = std::nullopt);
/** /**
Parse a child expression. For use by individual Expression::parse() methods. Parse a child expression. For use by individual Expression::parse() methods.
*/ */
ParseResult parse(const mbgl::style::conversion::Convertible&, ParseResult parse(const mbgl::style::conversion::Convertible&,
std::size_t index, std::size_t index,
optional<type::Type>, std::optional<type::Type>,
const std::map<std::string, std::shared_ptr<Expression>>&); const std::map<std::string, std::shared_ptr<Expression>>&);
/** /**
Check whether `t` is a subtype of `expected`, collecting an error if not. Check whether `t` is a subtype of `expected`, collecting an error if not.
*/ */
optional<std::string> checkType(const type::Type& t); std::optional<std::string> checkType(const type::Type& t);
optional<std::shared_ptr<Expression>> getBinding(const std::string& name) { std::optional<std::shared_ptr<Expression>> getBinding(const std::string& name) {
if (!scope) return optional<std::shared_ptr<Expression>>(); if (!scope) return std::optional<std::shared_ptr<Expression>>();
return scope->get(name); return scope->get(name);
} }
@@ -153,7 +153,7 @@ public:
private: private:
ParsingContext(std::string key_, ParsingContext(std::string key_,
std::shared_ptr<std::vector<ParsingError>> errors_, std::shared_ptr<std::vector<ParsingError>> errors_,
optional<type::Type> expected_, std::optional<type::Type> expected_,
std::shared_ptr<detail::Scope> scope_) std::shared_ptr<detail::Scope> scope_)
: key(std::move(key_)), : key(std::move(key_)),
expected(std::move(expected_)), expected(std::move(expected_)),
@@ -168,10 +168,10 @@ private:
type (either Literal, or the one named in value[0]) and dispatching to the type (either Literal, or the one named in value[0]) and dispatching to the
appropriate ParseXxxx::parse(const V&, ParsingContext) method. appropriate ParseXxxx::parse(const V&, ParsingContext) method.
*/ */
ParseResult parse(const mbgl::style::conversion::Convertible& value, const optional<TypeAnnotationOption>& = {}); ParseResult parse(const mbgl::style::conversion::Convertible& value, const std::optional<TypeAnnotationOption>& = std::nullopt);
std::string key; std::string key;
optional<type::Type> expected; std::optional<type::Type> expected;
std::shared_ptr<detail::Scope> scope; std::shared_ptr<detail::Scope> scope;
std::shared_ptr<std::vector<ParsingError>> errors; std::shared_ptr<std::vector<ParsingError>> errors;
}; };

3
include/mbgl/style/expression/step.hpp
View File

@@ -8,6 +8,7 @@
#include <memory> #include <memory>
#include <map> #include <map>
#include <optional>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
@@ -28,7 +29,7 @@ public:
bool operator==(const Expression& e) const override; bool operator==(const Expression& e) const override;
std::vector<optional<Value>> possibleOutputs() const override; std::vector<std::optional<Value>> possibleOutputs() const override;
static ParseResult parse(const mbgl::style::conversion::Convertible& value, ParsingContext& ctx); static ParseResult parse(const mbgl::style::conversion::Convertible& value, ParsingContext& ctx);

7
include/mbgl/style/expression/type.hpp
View File

@@ -1,10 +1,11 @@
#pragma once #pragma once
#include <mbgl/util/optional.hpp>
#include <mbgl/util/string.hpp> #include <mbgl/util/string.hpp>
#include <mbgl/util/variant.hpp> #include <mbgl/util/variant.hpp>
#include <vector> #include <vector>
#include <optional>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
namespace expression { namespace expression {
@@ -109,7 +110,7 @@ using Type = variant<NullType,
struct Array { struct Array {
explicit Array(Type itemType_) : itemType(std::move(itemType_)) {} explicit Array(Type itemType_) : itemType(std::move(itemType_)) {}
Array(Type itemType_, std::size_t N_) : itemType(std::move(itemType_)), N(N_) {} Array(Type itemType_, std::size_t N_) : itemType(std::move(itemType_)), N(N_) {}
Array(Type itemType_, optional<std::size_t> N_) : itemType(std::move(itemType_)), N(std::move(N_)) {} Array(Type itemType_, std::optional<std::size_t> N_) : itemType(std::move(itemType_)), N(std::move(N_)) {}
std::string getName() const { std::string getName() const {
if (N) { if (N) {
return "array<" + toString(itemType) + ", " + util::toString(*N) + ">"; return "array<" + toString(itemType) + ", " + util::toString(*N) + ">";
@@ -123,7 +124,7 @@ struct Array {
bool operator==(const Array& rhs) const { return itemType == rhs.itemType && N == rhs.N; } bool operator==(const Array& rhs) const { return itemType == rhs.itemType && N == rhs.N; }
Type itemType; Type itemType;
optional<std::size_t> N; std::optional<std::size_t> N;
}; };
template <class T> template <class T>

27
include/mbgl/style/expression/value.hpp
View File

@@ -14,6 +14,7 @@
#include <array> #include <array>
#include <vector> #include <vector>
#include <optional>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
@@ -77,8 +78,8 @@ struct ValueConverter {
return Value(value); return Value(value);
} }
static optional<T> fromExpressionValue(const Value& value) { static std::optional<T> fromExpressionValue(const Value& value) {
return value.template is<T>() ? value.template get<T>() : optional<T>(); return value.template is<T>() ? value.template get<T>() : std::optional<T>();
} }
}; };
@@ -86,7 +87,7 @@ template <>
struct ValueConverter<Value> { struct ValueConverter<Value> {
static type::Type expressionType() { return type::Value; } static type::Type expressionType() { return type::Value; }
static Value toExpressionValue(const Value& value) { return value; } static Value toExpressionValue(const Value& value) { return value; }
static optional<Value> fromExpressionValue(const Value& value) { return value; } static std::optional<Value> fromExpressionValue(const Value& value) { return value; }
}; };
template <> template <>
@@ -99,7 +100,7 @@ template <>
struct ValueConverter<float> { struct ValueConverter<float> {
static type::Type expressionType() { return type::Number; } static type::Type expressionType() { return type::Number; }
static Value toExpressionValue(float value); static Value toExpressionValue(float value);
static optional<float> fromExpressionValue(const Value& value); static std::optional<float> fromExpressionValue(const Value& value);
}; };
template <typename T, std::size_t N> template <typename T, std::size_t N>
@@ -108,7 +109,7 @@ struct ValueConverter<std::array<T, N>> {
return type::Array(valueTypeToExpressionType<T>(), N); return type::Array(valueTypeToExpressionType<T>(), N);
} }
static Value toExpressionValue(const std::array<T, N>& value); static Value toExpressionValue(const std::array<T, N>& value);
static optional<std::array<T, N>> fromExpressionValue(const Value& value); static std::optional<std::array<T, N>> fromExpressionValue(const Value& value);
}; };
template <typename T> template <typename T>
@@ -117,21 +118,21 @@ struct ValueConverter<std::vector<T>> {
return type::Array(valueTypeToExpressionType<T>()); return type::Array(valueTypeToExpressionType<T>());
} }
static Value toExpressionValue(const std::vector<T>& value); static Value toExpressionValue(const std::vector<T>& value);
static optional<std::vector<T>> fromExpressionValue(const Value& value); static std::optional<std::vector<T>> fromExpressionValue(const Value& value);
}; };
template <> template <>
struct ValueConverter<Position> { struct ValueConverter<Position> {
static type::Type expressionType() { return type::Array(type::Number, 3); } static type::Type expressionType() { return type::Array(type::Number, 3); }
static Value toExpressionValue(const mbgl::style::Position& value); static Value toExpressionValue(const mbgl::style::Position& value);
static optional<Position> fromExpressionValue(const Value& v); static std::optional<Position> fromExpressionValue(const Value& v);
}; };
template <typename T> template <typename T>
struct ValueConverter<T, std::enable_if_t< std::is_enum_v<T> >> { struct ValueConverter<T, std::enable_if_t< std::is_enum_v<T> >> {
static type::Type expressionType() { return type::String; } static type::Type expressionType() { return type::String; }
static Value toExpressionValue(const T& value); static Value toExpressionValue(const T& value);
static optional<T> fromExpressionValue(const Value& value); static std::optional<T> fromExpressionValue(const Value& value);
}; };
template <typename T> template <typename T>
@@ -140,16 +141,16 @@ Value toExpressionValue(const T& value) {
} }
template <typename T> template <typename T>
optional<T> fromExpressionValue(const Value& value) { std::optional<T> fromExpressionValue(const Value& value) {
return ValueConverter<T>::fromExpressionValue(value); return ValueConverter<T>::fromExpressionValue(value);
} }
template <typename T> template <typename T>
std::vector<optional<T>> fromExpressionValues(const std::vector<optional<Value>>& values) { std::vector<std::optional<T>> fromExpressionValues(const std::vector<std::optional<Value>>& values) {
std::vector<optional<T>> result; std::vector<std::optional<T>> result;
result.reserve(values.size()); result.reserve(values.size());
for (const auto& value : values) { for (const auto& value : values) {
result.push_back(value ? fromExpressionValue<T>(*value) : nullopt); result.push_back(value ? fromExpressionValue<T>(*value) : std::nullopt);
} }
return result; return result;
} }
@@ -158,7 +159,7 @@ template <>
struct ValueConverter<Rotation> { struct ValueConverter<Rotation> {
static type::Type expressionType() { return type::Number; } static type::Type expressionType() { return type::Number; }
static Value toExpressionValue(const mbgl::style::Rotation& value); static Value toExpressionValue(const mbgl::style::Rotation& value);
static optional<Rotation> fromExpressionValue(const Value& v); static std::optional<Rotation> fromExpressionValue(const Value& v);
}; };
} // namespace expression } // namespace expression

5
include/mbgl/style/expression/within.hpp
View File

@@ -2,7 +2,8 @@
#include <mbgl/style/expression/expression.hpp> #include <mbgl/style/expression/expression.hpp>
#include <mbgl/util/geojson.hpp> #include <mbgl/util/geojson.hpp>
#include <mbgl/util/optional.hpp>
#include <optional>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
@@ -22,7 +23,7 @@ public:
bool operator==(const Expression& e) const override; bool operator==(const Expression& e) const override;
std::vector<optional<Value>> possibleOutputs() const override; std::vector<std::optional<Value>> possibleOutputs() const override;
mbgl::Value serialize() const override; mbgl::Value serialize() const override;
std::string getOperator() const override; std::string getOperator() const override;

7
include/mbgl/style/filter.hpp
View File

@@ -8,19 +8,20 @@
#include <string> #include <string>
#include <vector> #include <vector>
#include <tuple> #include <tuple>
#include <optional>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
class Filter { class Filter {
public: public:
optional<std::shared_ptr<const expression::Expression>> expression; std::optional<std::shared_ptr<const expression::Expression>> expression;
private: private:
optional<mbgl::Value> legacyFilter; std::optional<mbgl::Value> legacyFilter;
public: public:
Filter() = default; Filter() = default;
Filter(expression::ParseResult _expression, optional<mbgl::Value> _filter = {}) Filter(expression::ParseResult _expression, std::optional<mbgl::Value> _filter = std::nullopt)
: expression(std::move(*_expression)), : expression(std::move(*_expression)),
legacyFilter(std::move(_filter)){ legacyFilter(std::move(_filter)){
assert(!expression || *expression != nullptr); assert(!expression || *expression != nullptr);

8
include/mbgl/style/image.hpp
View File

@@ -2,11 +2,11 @@
#include <mbgl/util/image.hpp> #include <mbgl/util/image.hpp>
#include <mbgl/util/immutable.hpp> #include <mbgl/util/immutable.hpp>
#include <mbgl/util/optional.hpp>
#include <string> #include <string>
#include <utility> #include <utility>
#include <vector> #include <vector>
#include <optional>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
@@ -34,13 +34,13 @@ public:
bool sdf, bool sdf,
ImageStretches stretchX = {}, ImageStretches stretchX = {},
ImageStretches stretchY = {}, ImageStretches stretchY = {},
const optional<ImageContent>& content = nullopt); const std::optional<ImageContent>& content = std::nullopt);
Image(std::string id, Image(std::string id,
PremultipliedImage&& image, PremultipliedImage&& image,
float pixelRatio, float pixelRatio,
ImageStretches stretchX = {}, ImageStretches stretchX = {},
ImageStretches stretchY = {}, ImageStretches stretchY = {},
const optional<ImageContent>& content = nullopt) const std::optional<ImageContent>& content = std::nullopt)
: Image(std::move(id), std::move(image), pixelRatio, false, std::move(stretchX), std::move(stretchY), content) { : Image(std::move(id), std::move(image), pixelRatio, false, std::move(stretchX), std::move(stretchY), content) {
} }
Image(const Image&); Image(const Image&);
@@ -61,7 +61,7 @@ public:
const ImageStretches& getStretchY() const; const ImageStretches& getStretchY() const;
/// The space where text can be fit into this image. /// The space where text can be fit into this image.
const optional<ImageContent>& getContent() const; const std::optional<ImageContent>& getContent() const;
class Impl; class Impl;
Immutable<Impl> baseImpl; Immutable<Impl> baseImpl;

12
include/mbgl/style/layer.hpp
View File

@@ -4,7 +4,6 @@
#include <mbgl/style/style_property.hpp> #include <mbgl/style/style_property.hpp>
#include <mbgl/style/types.hpp> #include <mbgl/style/types.hpp>
#include <mbgl/util/immutable.hpp> #include <mbgl/util/immutable.hpp>
#include <mbgl/util/optional.hpp>
#include <mapbox/std/weak.hpp> #include <mapbox/std/weak.hpp>
#include <mapbox/util/type_wrapper.hpp> #include <mapbox/util/type_wrapper.hpp>
@@ -13,6 +12,7 @@
#include <memory> #include <memory>
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <optional>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
@@ -111,7 +111,7 @@ public:
void setMaxZoom(float); void setMaxZoom(float);
// Dynamic properties // Dynamic properties
optional<conversion::Error> setProperty(const std::string& name, const conversion::Convertible& value); std::optional<conversion::Error> setProperty(const std::string& name, const conversion::Convertible& value);
virtual StyleProperty getProperty(const std::string&) const = 0; virtual StyleProperty getProperty(const std::string&) const = 0;
virtual Value serialize() const; virtual Value serialize() const;
@@ -144,15 +144,15 @@ public:
protected: protected:
virtual Mutable<Impl> mutableBaseImpl() const = 0; virtual Mutable<Impl> mutableBaseImpl() const = 0;
void serializeProperty(Value&, const StyleProperty&, const char* propertyName, bool isPaint) const; void serializeProperty(Value&, const StyleProperty&, const char* propertyName, bool isPaint) const;
virtual optional<conversion::Error> setPropertyInternal(const std::string& name, virtual std::optional<conversion::Error> setPropertyInternal(const std::string& name,
const conversion::Convertible& value) = 0; const conversion::Convertible& value) = 0;
LayerObserver* observer; LayerObserver* observer;
mapbox::base::WeakPtrFactory<Layer> weakFactory {this}; mapbox::base::WeakPtrFactory<Layer> weakFactory {this};
private: private:
optional<conversion::Error> setVisibility(const conversion::Convertible& value); std::optional<conversion::Error> setVisibility(const conversion::Convertible& value);
optional<conversion::Error> setMinZoom(const conversion::Convertible& value); std::optional<conversion::Error> setMinZoom(const conversion::Convertible& value);
optional<conversion::Error> setMaxZoom(const conversion::Convertible& value); std::optional<conversion::Error> setMaxZoom(const conversion::Convertible& value);
}; };
} // namespace style } // namespace style

2
include/mbgl/style/layers/background_layer.hpp
View File

@@ -50,7 +50,7 @@ public:
protected: protected:
// Dynamic properties // Dynamic properties
optional<conversion::Error> setPropertyInternal(const std::string& name, const conversion::Convertible& value) final; std::optional<conversion::Error> setPropertyInternal(const std::string& name, const conversion::Convertible& value) final;
StyleProperty getProperty(const std::string& name) const final; StyleProperty getProperty(const std::string& name) const final;
Value serialize() const final; Value serialize() const final;

2
include/mbgl/style/layers/circle_layer.hpp
View File

@@ -104,7 +104,7 @@ public:
protected: protected:
// Dynamic properties // Dynamic properties
optional<conversion::Error> setPropertyInternal(const std::string& name, const conversion::Convertible& value) final; std::optional<conversion::Error> setPropertyInternal(const std::string& name, const conversion::Convertible& value) final;
StyleProperty getProperty(const std::string& name) const final; StyleProperty getProperty(const std::string& name) const final;
Value serialize() const final; Value serialize() const final;

2
include/mbgl/style/layers/fill_extrusion_layer.hpp
View File

@@ -80,7 +80,7 @@ public:
protected: protected:
// Dynamic properties // Dynamic properties
optional<conversion::Error> setPropertyInternal(const std::string& name, const conversion::Convertible& value) final; std::optional<conversion::Error> setPropertyInternal(const std::string& name, const conversion::Convertible& value) final;
StyleProperty getProperty(const std::string& name) const final; StyleProperty getProperty(const std::string& name) const final;
Value serialize() const final; Value serialize() const final;

2
include/mbgl/style/layers/fill_layer.hpp
View File

@@ -80,7 +80,7 @@ public:
protected: protected:
// Dynamic properties // Dynamic properties
optional<conversion::Error> setPropertyInternal(const std::string& name, const conversion::Convertible& value) final; std::optional<conversion::Error> setPropertyInternal(const std::string& name, const conversion::Convertible& value) final;
StyleProperty getProperty(const std::string& name) const final; StyleProperty getProperty(const std::string& name) const final;
Value serialize() const final; Value serialize() const final;

2
include/mbgl/style/layers/heatmap_layer.hpp
View File

@@ -63,7 +63,7 @@ public:
protected: protected:
// Dynamic properties // Dynamic properties
optional<conversion::Error> setPropertyInternal(const std::string& name, const conversion::Convertible& value) final; std::optional<conversion::Error> setPropertyInternal(const std::string& name, const conversion::Convertible& value) final;
StyleProperty getProperty(const std::string& name) const final; StyleProperty getProperty(const std::string& name) const final;
Value serialize() const final; Value serialize() const final;

2
include/mbgl/style/layers/hillshade_layer.hpp
View File

@@ -68,7 +68,7 @@ public:
protected: protected:
// Dynamic properties // Dynamic properties
optional<conversion::Error> setPropertyInternal(const std::string& name, const conversion::Convertible& value) final; std::optional<conversion::Error> setPropertyInternal(const std::string& name, const conversion::Convertible& value) final;
StyleProperty getProperty(const std::string& name) const final; StyleProperty getProperty(const std::string& name) const final;
Value serialize() const final; Value serialize() const final;

2
include/mbgl/style/layers/layer.hpp.ejs
View File

@@ -72,7 +72,7 @@ public:
protected: protected:
// Dynamic properties // Dynamic properties
optional<conversion::Error> setPropertyInternal(const std::string& name, const conversion::Convertible& value) final; std::optional<conversion::Error> setPropertyInternal(const std::string& name, const conversion::Convertible& value) final;
StyleProperty getProperty(const std::string& name) const final; StyleProperty getProperty(const std::string& name) const final;
Value serialize() const final; Value serialize() const final;

2
include/mbgl/style/layers/line_layer.hpp
View File

@@ -123,7 +123,7 @@ public:
protected: protected:
// Dynamic properties // Dynamic properties
optional<conversion::Error> setPropertyInternal(const std::string& name, const conversion::Convertible& value) final; std::optional<conversion::Error> setPropertyInternal(const std::string& name, const conversion::Convertible& value) final;
StyleProperty getProperty(const std::string& name) const final; StyleProperty getProperty(const std::string& name) const final;
Value serialize() const final; Value serialize() const final;

2
include/mbgl/style/layers/location_indicator_layer.hpp
View File

@@ -107,7 +107,7 @@ public:
protected: protected:
// Dynamic properties // Dynamic properties
optional<conversion::Error> setPropertyInternal(const std::string& name, const conversion::Convertible& value) final; std::optional<conversion::Error> setPropertyInternal(const std::string& name, const conversion::Convertible& value) final;
StyleProperty getProperty(const std::string& name) const final; StyleProperty getProperty(const std::string& name) const final;
Value serialize() const final; Value serialize() const final;

2
include/mbgl/style/layers/raster_layer.hpp
View File

@@ -80,7 +80,7 @@ public:
protected: protected:
// Dynamic properties // Dynamic properties
optional<conversion::Error> setPropertyInternal(const std::string& name, const conversion::Convertible& value) final; std::optional<conversion::Error> setPropertyInternal(const std::string& name, const conversion::Convertible& value) final;
StyleProperty getProperty(const std::string& name) const final; StyleProperty getProperty(const std::string& name) const final;
Value serialize() const final; Value serialize() const final;

2
include/mbgl/style/layers/symbol_layer.hpp
View File

@@ -285,7 +285,7 @@ public:
protected: protected:
// Dynamic properties // Dynamic properties
optional<conversion::Error> setPropertyInternal(const std::string& name, const conversion::Convertible& value) final; std::optional<conversion::Error> setPropertyInternal(const std::string& name, const conversion::Convertible& value) final;
StyleProperty getProperty(const std::string& name) const final; StyleProperty getProperty(const std::string& name) const final;
Value serialize() const final; Value serialize() const final;

2
include/mbgl/style/light.hpp
View File

@@ -22,7 +22,7 @@ public:
~Light(); ~Light();
// Dynamic properties // Dynamic properties
optional<conversion::Error> setProperty(const std::string& name, const conversion::Convertible& value); std::optional<conversion::Error> setProperty(const std::string& name, const conversion::Convertible& value);
StyleProperty getProperty(const std::string&) const; StyleProperty getProperty(const std::string&) const;
static LightAnchorType getDefaultAnchor(); static LightAnchorType getDefaultAnchor();

2
include/mbgl/style/light.hpp.ejs
View File

@@ -25,7 +25,7 @@ public:
~Light(); ~Light();
// Dynamic properties // Dynamic properties
optional<conversion::Error> setProperty(const std::string& name, const conversion::Convertible& value); std::optional<conversion::Error> setProperty(const std::string& name, const conversion::Convertible& value);
StyleProperty getProperty(const std::string&) const; StyleProperty getProperty(const std::string&) const;
<% for (const property of properties) { -%> <% for (const property of properties) { -%>

10
include/mbgl/style/property_expression.hpp
View File

@@ -7,6 +7,8 @@
#include <mbgl/style/expression/find_zoom_curve.hpp> #include <mbgl/style/expression/find_zoom_curve.hpp>
#include <mbgl/util/range.hpp> #include <mbgl/util/range.hpp>
#include <optional>
namespace mbgl { namespace mbgl {
namespace style { namespace style {
@@ -40,7 +42,7 @@ template <class T>
class PropertyExpression final : public PropertyExpressionBase { class PropertyExpression final : public PropertyExpressionBase {
public: public:
// Second parameter to be used only for conversions from legacy functions. // Second parameter to be used only for conversions from legacy functions.
PropertyExpression(std::unique_ptr<expression::Expression> expression_, optional<T> defaultValue_ = nullopt) PropertyExpression(std::unique_ptr<expression::Expression> expression_, std::optional<T> defaultValue_ = std::nullopt)
: PropertyExpressionBase(std::move(expression_)), : PropertyExpressionBase(std::move(expression_)),
defaultValue(std::move(defaultValue_)) { defaultValue(std::move(defaultValue_)) {
} }
@@ -48,7 +50,7 @@ public:
T evaluate(const expression::EvaluationContext& context, T finalDefaultValue = T()) const { T evaluate(const expression::EvaluationContext& context, T finalDefaultValue = T()) const {
const expression::EvaluationResult result = expression->evaluate(context); const expression::EvaluationResult result = expression->evaluate(context);
if (result) { if (result) {
const optional<T> typed = expression::fromExpressionValue<T>(*result); const std::optional<T> typed = expression::fromExpressionValue<T>(*result);
return typed ? *typed : defaultValue ? *defaultValue : finalDefaultValue; return typed ? *typed : defaultValue ? *defaultValue : finalDefaultValue;
} }
return defaultValue ? *defaultValue : finalDefaultValue; return defaultValue ? *defaultValue : finalDefaultValue;
@@ -123,7 +125,7 @@ public:
return evaluate(expression::EvaluationContext(zoom, &feature, &state), finalDefaultValue); return evaluate(expression::EvaluationContext(zoom, &feature, &state), finalDefaultValue);
} }
std::vector<optional<T>> possibleOutputs() const { std::vector<std::optional<T>> possibleOutputs() const {
return expression::fromExpressionValues<T>(expression->possibleOutputs()); return expression::fromExpressionValues<T>(expression->possibleOutputs());
} }
@@ -133,7 +135,7 @@ public:
} }
private: private:
optional<T> defaultValue; std::optional<T> defaultValue;
}; };
} // namespace style } // namespace style

12
include/mbgl/style/source.hpp
View File

@@ -3,13 +3,13 @@
#include <mbgl/style/types.hpp> #include <mbgl/style/types.hpp>
#include <mbgl/util/chrono.hpp> #include <mbgl/util/chrono.hpp>
#include <mbgl/util/immutable.hpp> #include <mbgl/util/immutable.hpp>
#include <mbgl/util/optional.hpp>
#include <mapbox/std/weak.hpp> #include <mapbox/std/weak.hpp>
#include <mapbox/util/type_wrapper.hpp> #include <mapbox/util/type_wrapper.hpp>
#include <memory> #include <memory>
#include <string> #include <string>
#include <optional>
namespace mbgl { namespace mbgl {
@@ -64,7 +64,7 @@ public:
SourceType getType() const; SourceType getType() const;
std::string getID() const; std::string getID() const;
optional<std::string> getAttribution() const; std::optional<std::string> getAttribution() const;
// The data from the volatile sources are not stored in a persistent storage. // The data from the volatile sources are not stored in a persistent storage.
bool isVolatile() const noexcept; bool isVolatile() const noexcept;
@@ -80,8 +80,8 @@ public:
SourceObserver* observer = nullptr; SourceObserver* observer = nullptr;
virtual void loadDescription(FileSource&) = 0; virtual void loadDescription(FileSource&) = 0;
void setPrefetchZoomDelta(optional<uint8_t> delta) noexcept; void setPrefetchZoomDelta(std::optional<uint8_t> delta) noexcept;
optional<uint8_t> getPrefetchZoomDelta() const noexcept; std::optional<uint8_t> getPrefetchZoomDelta() const noexcept;
// If the given source supports loading tiles from a server, // If the given source supports loading tiles from a server,
// sets the minimum tile update interval. // sets the minimum tile update interval.
@@ -103,8 +103,8 @@ public:
// minimum zoom level of a parent tile that could be used in place of an ideal // minimum zoom level of a parent tile that could be used in place of an ideal
// tile during rendering would be zoom 0. By default, no limit is set, so any // tile during rendering would be zoom 0. By default, no limit is set, so any
// parent tile may be used. // parent tile may be used.
void setMaxOverscaleFactorForParentTiles(optional<uint8_t> overscaleFactor) noexcept; void setMaxOverscaleFactorForParentTiles(std::optional<uint8_t> overscaleFactor) noexcept;
optional<uint8_t> getMaxOverscaleFactorForParentTiles() const noexcept; std::optional<uint8_t> getMaxOverscaleFactorForParentTiles() const noexcept;
void dumpDebugLogs() const; void dumpDebugLogs() const;
virtual bool supportsLayerType(const mbgl::style::LayerTypeInfo*) const = 0; virtual bool supportsLayerType(const mbgl::style::LayerTypeInfo*) const = 0;

5
include/mbgl/style/sources/geojson_source.hpp
View File

@@ -5,7 +5,6 @@
#include <mbgl/tile/tile_id.hpp> #include <mbgl/tile/tile_id.hpp>
#include <mbgl/util/constants.hpp> #include <mbgl/util/constants.hpp>
#include <mbgl/util/geojson.hpp> #include <mbgl/util/geojson.hpp>
#include <mbgl/util/optional.hpp>
#include <map> #include <map>
#include <memory> #include <memory>
@@ -65,7 +64,7 @@ public:
void setGeoJSON(const GeoJSON&); void setGeoJSON(const GeoJSON&);
void setGeoJSONData(std::shared_ptr<GeoJSONData>); void setGeoJSONData(std::shared_ptr<GeoJSONData>);
optional<std::string> getURL() const; std::optional<std::string> getURL() const;
const GeoJSONOptions& getOptions() const; const GeoJSONOptions& getOptions() const;
class Impl; class Impl;
@@ -83,7 +82,7 @@ protected:
Mutable<Source::Impl> createMutable() const noexcept final; Mutable<Source::Impl> createMutable() const noexcept final;
private: private:
optional<std::string> url; std::optional<std::string> url;
std::unique_ptr<AsyncRequest> req; std::unique_ptr<AsyncRequest> req;
std::shared_ptr<Scheduler> threadPool; std::shared_ptr<Scheduler> threadPool;
mapbox::base::WeakPtrFactory<Source> weakFactory {this}; mapbox::base::WeakPtrFactory<Source> weakFactory {this};

7
include/mbgl/style/sources/image_source.hpp
View File

@@ -2,7 +2,8 @@
#include <mbgl/style/source.hpp> #include <mbgl/style/source.hpp>
#include <mbgl/util/image.hpp> #include <mbgl/util/image.hpp>
#include <mbgl/util/optional.hpp>
#include <optional>
namespace mbgl { namespace mbgl {
class LatLng; class LatLng;
@@ -15,7 +16,7 @@ public:
ImageSource(std::string id, std::array<LatLng, 4>); ImageSource(std::string id, std::array<LatLng, 4>);
~ImageSource() override; ~ImageSource() override;
optional<std::string> getURL() const; std::optional<std::string> getURL() const;
void setURL(const std::string& url); void setURL(const std::string& url);
void setImage(PremultipliedImage&&); void setImage(PremultipliedImage&&);
@@ -38,7 +39,7 @@ protected:
Mutable<Source::Impl> createMutable() const noexcept final; Mutable<Source::Impl> createMutable() const noexcept final;
private: private:
optional<std::string> url; std::optional<std::string> url;
std::unique_ptr<AsyncRequest> req; std::unique_ptr<AsyncRequest> req;
mapbox::base::WeakPtrFactory<Source> weakFactory {this}; mapbox::base::WeakPtrFactory<Source> weakFactory {this};
}; };

2
include/mbgl/style/sources/raster_source.hpp
View File

@@ -16,7 +16,7 @@ public:
~RasterSource() override; ~RasterSource() override;
const variant<std::string, Tileset>& getURLOrTileset() const; const variant<std::string, Tileset>& getURLOrTileset() const;
optional<std::string> getURL() const; std::optional<std::string> getURL() const;
uint16_t getTileSize() const; uint16_t getTileSize() const;

10
include/mbgl/style/sources/vector_source.hpp
View File

@@ -12,12 +12,12 @@ namespace style {
class VectorSource final : public Source { class VectorSource final : public Source {
public: public:
VectorSource(std::string id, variant<std::string, Tileset> urlOrTileset, optional<float> maxZoom = nullopt, VectorSource(std::string id, variant<std::string, Tileset> urlOrTileset, std::optional<float> maxZoom = std::nullopt,
optional<float> minZoom = nullopt); std::optional<float> minZoom = std::nullopt);
~VectorSource() final; ~VectorSource() final;
const variant<std::string, Tileset>& getURLOrTileset() const; const variant<std::string, Tileset>& getURLOrTileset() const;
optional<std::string> getURL() const; std::optional<std::string> getURL() const;
class Impl; class Impl;
const Impl& impl() const; const Impl& impl() const;
@@ -37,8 +37,8 @@ private:
const variant<std::string, Tileset> urlOrTileset; const variant<std::string, Tileset> urlOrTileset;
std::unique_ptr<AsyncRequest> req; std::unique_ptr<AsyncRequest> req;
mapbox::base::WeakPtrFactory<Source> weakFactory {this}; mapbox::base::WeakPtrFactory<Source> weakFactory {this};
optional<float> maxZoom; std::optional<float> maxZoom;
optional<float> minZoom; std::optional<float> minZoom;
}; };
template <> template <>

Some files were not shown because too many files have changed in this diff Show More