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

[core] GCC 4.9 bracket initialization issues

Browse Source
This commit is contained in:
Bruno de Oliveira Abinader
2017-07-11 19:19:04 +03:00
parent 2fae373fc9
commit 4014aa6721
16 changed files with 93 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -41,7 +41,7 @@ public:
GLContextMode contextMode = GLContextMode::Unique,
ConstrainMode constrainMode = ConstrainMode::HeightOnly,
ViewportMode viewportMode = ViewportMode::Default,
const optional<std::string>& programCacheDir = {});
optional<std::string> programCacheDir = optional<std::string>());
~Map();
// Register a callback that will get called (on the render thread) when all resources have

4
include/mbgl/style/transition_options.hpp
View File

@@ -8,8 +8,8 @@ namespace style {
class TransitionOptions {
public:
optional<Duration> duration = {};
optional<Duration> delay = {};
optional<Duration> duration;
optional<Duration> delay;
TransitionOptions(optional<Duration> duration_ = optional<Duration>(),
optional<Duration> delay_ = optional<Duration>())

2
include/mbgl/util/convert.hpp
View File

@@ -10,7 +10,7 @@ namespace util {
template<typename To, typename From, std::size_t Size,
typename = std::enable_if_t<std::is_convertible<From, To>::value>>
MBGL_CONSTEXPR std::array<To, Size> convert(const std::array<From, Size>&from) {
std::array<To, Size> to {};
std::array<To, Size> to {{}};
std::copy(std::begin(from), std::end(from), std::begin(to));
return to;
}

22
platform/qt/app/mapwindow.cpp
View File

@@ -254,8 +254,13 @@ void MapWindow::keyPressEvent(QKeyEvent *ev)
if (m_lineAnnotationId.isNull()) {
QMapbox::Coordinate topLeft = m_map->coordinateForPixel({ 0, 0 });
QMapbox::Coordinate bottomRight = m_map->coordinateForPixel({ qreal(size().width()), qreal(size().height()) });
QMapbox::CoordinatesCollections geometry { { { topLeft, bottomRight } } };
QMapbox::LineAnnotation line { { QMapbox::ShapeAnnotationGeometry::LineStringType, geometry }, 0.5f, 1.0f, Qt::red };
QMapbox::CoordinatesCollections lineGeometry { { { topLeft, bottomRight } } };
QMapbox::ShapeAnnotationGeometry annotationGeometry { QMapbox::ShapeAnnotationGeometry::LineStringType, lineGeometry };
QMapbox::LineAnnotation line;
line.geometry = annotationGeometry;
line.opacity = 0.5f;
line.width = 1.0f;
line.color = Qt::red;
m_lineAnnotationId = m_map->addAnnotation(QVariant::fromValue<QMapbox::LineAnnotation>(line));
} else {
m_map->removeAnnotation(m_lineAnnotationId.toUInt());
@@ -269,8 +274,13 @@ void MapWindow::keyPressEvent(QKeyEvent *ev)
QMapbox::Coordinate topRight = m_map->coordinateForPixel({ 0, qreal(size().height()) });
QMapbox::Coordinate bottomLeft = m_map->coordinateForPixel({ qreal(size().width()), 0 });
QMapbox::Coordinate bottomRight = m_map->coordinateForPixel({ qreal(size().width()), qreal(size().height()) });
QMapbox::CoordinatesCollections geometry { { { bottomLeft, bottomRight, topRight, topLeft, bottomLeft } } };
QMapbox::FillAnnotation fill { { QMapbox::ShapeAnnotationGeometry::PolygonType, geometry }, 0.5f, Qt::green, QVariant::fromValue<QColor>(QColor(Qt::black)) };
QMapbox::CoordinatesCollections fillGeometry { { { bottomLeft, bottomRight, topRight, topLeft, bottomLeft } } };
QMapbox::ShapeAnnotationGeometry annotationGeometry { QMapbox::ShapeAnnotationGeometry::PolygonType, fillGeometry };
QMapbox::FillAnnotation fill;
fill.geometry = annotationGeometry;
fill.opacity = 0.5f;
fill.color = Qt::green;
fill.outlineColor = QVariant::fromValue<QColor>(QColor(Qt::black));
m_fillAnnotationId = m_map->addAnnotation(QVariant::fromValue<QMapbox::FillAnnotation>(fill));
} else {
m_map->removeAnnotation(m_fillAnnotationId.toUInt());
@@ -283,8 +293,8 @@ void MapWindow::keyPressEvent(QKeyEvent *ev)
m_map->removeLayer("circleLayer");
m_map->removeSource("circleSource");
} else {
QMapbox::CoordinatesCollections geometry { { { m_map->coordinate() } } };
QMapbox::Feature feature { QMapbox::Feature::PointType, geometry, {}, {} };
QMapbox::CoordinatesCollections point { { { m_map->coordinate() } } };
QMapbox::Feature feature { QMapbox::Feature::PointType, point, {}, {} };
QVariantMap circleSource;
circleSource["type"] = "geojson";

2
src/mbgl/annotation/fill_annotation_impl.cpp
View File

@@ -9,7 +9,7 @@ using namespace style;
FillAnnotationImpl::FillAnnotationImpl(AnnotationID id_, FillAnnotation annotation_, uint8_t maxZoom_)
: ShapeAnnotationImpl(id_, maxZoom_),
annotation({ ShapeAnnotationGeometry::visit(annotation_.geometry, CloseShapeAnnotation{}), annotation_.opacity, annotation_.color, annotation_.outlineColor }) {
annotation(ShapeAnnotationGeometry::visit(annotation_.geometry, CloseShapeAnnotation{}), annotation_.opacity, annotation_.color, annotation_.outlineColor) {
}
void FillAnnotationImpl::updateStyle(Style::Impl& style) const {

2
src/mbgl/annotation/line_annotation_impl.cpp
View File

@@ -9,7 +9,7 @@ using namespace style;
LineAnnotationImpl::LineAnnotationImpl(AnnotationID id_, LineAnnotation annotation_, uint8_t maxZoom_)
: ShapeAnnotationImpl(id_, maxZoom_),
annotation({ ShapeAnnotationGeometry::visit(annotation_.geometry, CloseShapeAnnotation{}), annotation_.opacity, annotation_.width, annotation_.color }) {
annotation(ShapeAnnotationGeometry::visit(annotation_.geometry, CloseShapeAnnotation{}), annotation_.opacity, annotation_.width, annotation_.color) {
}
void LineAnnotationImpl::updateStyle(Style::Impl& style) const {

4
src/mbgl/gl/uniform.hpp
View File

@@ -48,6 +48,8 @@ public:
class State {
public:
State(UniformLocation location_) : location(std::move(location_)) {}
void operator=(const Value& value) {
if (location >= 0 && (!current || *current != value.t)) {
current = value.t;
@@ -106,7 +108,7 @@ public:
template <class Program>
static State loadNamedLocations(const Program& program) {
return State{ { program.uniformLocation(Us::name()) }... };
return State(typename Us::State(program.uniformLocation(Us::name()))...);
}
static NamedLocations getNamedLocations(const State& state) {

2
src/mbgl/map/map.cpp
View File

@@ -111,7 +111,7 @@ Map::Map(Backend& backend,
GLContextMode contextMode,
ConstrainMode constrainMode,
ViewportMode viewportMode,
const optional<std::string>& programCacheDir)
optional<std::string> programCacheDir)
: impl(std::make_unique<Impl>(*this,
backend,
pixelRatio,

4
src/mbgl/renderer/sources/render_image_source.cpp
View File

@@ -60,11 +60,11 @@ RenderImageSource::queryRenderedFeatures(const ScreenLineString&,
const TransformState&,
const RenderStyle&,
const RenderedQueryOptions&) const {
return {};
return std::unordered_map<std::string, std::vector<Feature>>();
}
std::vector<Feature> RenderImageSource::querySourceFeatures(const SourceQueryOptions&) const {
return {};
return std::vector<Feature>();
}
void RenderImageSource::update(Immutable<style::Source::Impl> baseImpl_,

4
src/mbgl/renderer/sources/render_raster_source.cpp
View File

@@ -73,11 +73,11 @@ RenderRasterSource::queryRenderedFeatures(const ScreenLineString&,
const TransformState&,
const RenderStyle&,
const RenderedQueryOptions&) const {
return {};
return std::unordered_map<std::string, std::vector<Feature>>();
}
std::vector<Feature> RenderRasterSource::querySourceFeatures(const SourceQueryOptions&) const {
return {};
return std::vector<Feature>();
}
void RenderRasterSource::onLowMemory() {

16
test/gl/bucket.test.cpp
View File

@@ -14,6 +14,12 @@
using namespace mbgl;
namespace {
PropertyMap properties;
} // namespace
TEST(Buckets, CircleBucket) {
gl::Context context;
CircleBucket bucket { { {0, 0, 0}, MapMode::Still, 1.0 }, {} };
@@ -21,7 +27,7 @@ TEST(Buckets, CircleBucket) {
ASSERT_FALSE(bucket.needsUpload());
GeometryCollection point { { { 0, 0 } } };
bucket.addFeature(StubGeometryTileFeature { {}, FeatureType::Point, point, {} }, point);
bucket.addFeature(StubGeometryTileFeature { {}, FeatureType::Point, point, properties }, point);
ASSERT_TRUE(bucket.hasData());
ASSERT_TRUE(bucket.needsUpload());
@@ -37,7 +43,7 @@ TEST(Buckets, FillBucket) {
ASSERT_FALSE(bucket.needsUpload());
GeometryCollection polygon { { { 0, 0 }, { 0, 1 }, { 1, 1 } } };
bucket.addFeature(StubGeometryTileFeature { {}, FeatureType::Polygon, polygon, {} }, polygon);
bucket.addFeature(StubGeometryTileFeature { {}, FeatureType::Polygon, polygon, properties }, polygon);
ASSERT_TRUE(bucket.hasData());
ASSERT_TRUE(bucket.needsUpload());
@@ -53,11 +59,11 @@ TEST(Buckets, LineBucket) {
// Ignore invalid feature type.
GeometryCollection point { { { 0, 0 } } };
bucket.addFeature(StubGeometryTileFeature { {}, FeatureType::Point, point, {} }, point);
bucket.addFeature(StubGeometryTileFeature { {}, FeatureType::Point, point, properties }, point);
ASSERT_FALSE(bucket.hasData());
GeometryCollection line { { { 0, 0 }, { 1, 1 } } };
bucket.addFeature(StubGeometryTileFeature { {}, FeatureType::LineString, line, {} }, line);
bucket.addFeature(StubGeometryTileFeature { {}, FeatureType::LineString, line, properties }, line);
ASSERT_TRUE(bucket.hasData());
ASSERT_TRUE(bucket.needsUpload());
@@ -80,7 +86,7 @@ TEST(Buckets, SymbolBucket) {
// SymbolBucket::addFeature() is a no-op.
GeometryCollection point { { { 0, 0 } } };
bucket.addFeature(StubGeometryTileFeature { {}, FeatureType::Point, point, {} }, point);
bucket.addFeature(StubGeometryTileFeature { {}, FeatureType::Point, point, properties }, point);
ASSERT_FALSE(bucket.hasData());
ASSERT_FALSE(bucket.needsUpload());

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

@@ -17,9 +17,9 @@ public:
}
PropertyMap properties;
optional<FeatureIdentifier> id = {};
optional<FeatureIdentifier> id;
FeatureType type = FeatureType::Point;
GeometryCollection geometry = {};
GeometryCollection geometry;
FeatureType getType() const override {
return type;

9
test/style/function/source_function.test.cpp
View File

@@ -76,11 +76,14 @@ TEST(SourceFunction, Categorical) {
EXPECT_EQ(0.0f, SourceFunction<float>("property", CategoricalStops<float>({{ int64_t(1), 1.0f }}))
.evaluate(oneString, 0.0f));
EXPECT_EQ(0.0f, SourceFunction<float>("property", CategoricalStops<float>({{ "1"s, 1.0f }}))
CategoricalStops<float>::Stops stops;
stops["1"s] = 1.0f;
EXPECT_EQ(0.0f, SourceFunction<float>("property", CategoricalStops<float>(stops))
.evaluate(oneInteger, 0.0f));
EXPECT_EQ(0.0f, SourceFunction<float>("property", CategoricalStops<float>({{ "1"s, 1.0f }}))
EXPECT_EQ(0.0f, SourceFunction<float>("property", CategoricalStops<float>(stops))
.evaluate(oneDouble, 0.0f));
EXPECT_EQ(1.0f, SourceFunction<float>("property", CategoricalStops<float>({{ "1"s, 1.0f }}))
EXPECT_EQ(1.0f, SourceFunction<float>("property", CategoricalStops<float>(stops))
.evaluate(oneString, 0.0f));
EXPECT_EQ(1.0f, SourceFunction<float>("property", CategoricalStops<float>({{ true, 1.0f }}))

6
test/tile/annotation_tile.test.cpp
View File

@@ -58,7 +58,7 @@ TEST(AnnotationTile, Issue8289) {
// Simulate layout and placement of a symbol layer.
tile.onLayout(GeometryTile::LayoutResult {
{},
std::unordered_map<std::string, std::shared_ptr<Bucket>>(),
std::make_unique<FeatureIndex>(),
std::move(data),
0
@@ -72,7 +72,7 @@ TEST(AnnotationTile, Issue8289) {
collisionTile->placeFeature(feature, false, false);
tile.onPlacement(GeometryTile::PlacementResult {
{},
std::unordered_map<std::string, std::shared_ptr<Bucket>>(),
std::move(collisionTile),
{},
{},
@@ -81,7 +81,7 @@ TEST(AnnotationTile, Issue8289) {
// Simulate a second layout with empty data.
tile.onLayout(GeometryTile::LayoutResult {
{},
std::unordered_map<std::string, std::shared_ptr<Bucket>>(),
std::make_unique<FeatureIndex>(),
std::make_unique<AnnotationTileData>(),
0

2
test/tile/vector_tile.test.cpp
View File

@@ -89,7 +89,7 @@ TEST(VectorTile, Issue7615) {
// Subsequent onLayout should not cause the existing symbol bucket to be discarded.
tile.onLayout(GeometryTile::LayoutResult {
{},
std::unordered_map<std::string, std::shared_ptr<Bucket>>(),
nullptr,
nullptr,
0

73
test/util/merge_lines.test.cpp
View File

@@ -10,15 +10,22 @@ const std::u16string bbb = u"b";
using namespace mbgl;
namespace {
PropertyMap properties;
LineString<int16_t> emptyLine;
}
class SymbolFeatureStub : public SymbolFeature {
public:
SymbolFeatureStub(optional<FeatureIdentifier> id_, FeatureType type_, GeometryCollection geometry_,
std::unordered_map<std::string, Value> properties_, optional<std::u16string> text_,
optional<std::string> icon_, std::size_t index_) :
SymbolFeature(std::make_unique<StubGeometryTileFeature>(id_, type_, geometry_, properties_))
PropertyMap properties_, optional<std::u16string> text_,
optional<std::string> icon_, std::size_t index_) :
SymbolFeature(std::make_unique<StubGeometryTileFeature>(std::move(id_), type_, std::move(geometry_), std::move(properties_)))
{
text = text_;
icon = icon_;
text = std::move(text_);
icon = std::move(icon_);
index = index_;
}
};
@@ -26,20 +33,20 @@ public:
TEST(MergeLines, SameText) {
// merges lines with the same text
std::vector<mbgl::SymbolFeature> input1;
input1.push_back(SymbolFeatureStub({}, FeatureType::LineString, {{{0, 0}, {1, 0}, {2, 0}}}, {}, aaa, {}, 0));
input1.push_back(SymbolFeatureStub({}, FeatureType::LineString, {{{4, 0}, {5, 0}, {6, 0}}}, {}, bbb, {}, 0));
input1.push_back(SymbolFeatureStub({}, FeatureType::LineString, {{{8, 0}, {9, 0}}}, {}, aaa, {}, 0));
input1.push_back(SymbolFeatureStub({}, FeatureType::LineString, {{{2, 0}, {3, 0}, {4, 0}}}, {}, aaa, {}, 0));
input1.push_back(SymbolFeatureStub({}, FeatureType::LineString, {{{6, 0}, {7, 0}, {8, 0}}}, {}, aaa, {}, 0));
input1.push_back(SymbolFeatureStub({}, FeatureType::LineString, {{{5, 0}, {6, 0}}}, {}, aaa, {}, 0));
input1.push_back(SymbolFeatureStub({}, FeatureType::LineString, {{{0, 0}, {1, 0}, {2, 0}}}, properties, aaa, {}, 0));
input1.push_back(SymbolFeatureStub({}, FeatureType::LineString, {{{4, 0}, {5, 0}, {6, 0}}}, properties, bbb, {}, 0));
input1.push_back(SymbolFeatureStub({}, FeatureType::LineString, {{{8, 0}, {9, 0}}}, properties, aaa, {}, 0));
input1.push_back(SymbolFeatureStub({}, FeatureType::LineString, {{{2, 0}, {3, 0}, {4, 0}}}, properties, aaa, {}, 0));
input1.push_back(SymbolFeatureStub({}, FeatureType::LineString, {{{6, 0}, {7, 0}, {8, 0}}}, properties, aaa, {}, 0));
input1.push_back(SymbolFeatureStub({}, FeatureType::LineString, {{{5, 0}, {6, 0}}}, properties, aaa, {}, 0));
const std::vector<StubGeometryTileFeature> expected1 = {
{ {}, FeatureType::LineString, {{{0, 0}, {1, 0}, {2, 0}, {3, 0}, {4, 0}}}, {} },
{ {}, FeatureType::LineString, {{{4, 0}, {5, 0}, {6, 0}}}, {} },
{ {}, FeatureType::LineString, {{{5, 0}, {6, 0}, {7, 0}, {8, 0}, {9, 0}}}, {} },
{ {}, FeatureType::LineString, {{}}, {} },
{ {}, FeatureType::LineString, {{}}, {} },
{ {}, FeatureType::LineString, {{}}, {} }
{ {}, FeatureType::LineString, {{{0, 0}, {1, 0}, {2, 0}, {3, 0}, {4, 0}}}, properties },
{ {}, FeatureType::LineString, {{{4, 0}, {5, 0}, {6, 0}}}, properties },
{ {}, FeatureType::LineString, {{{5, 0}, {6, 0}, {7, 0}, {8, 0}, {9, 0}}}, properties },
{ {}, FeatureType::LineString, { emptyLine }, properties },
{ {}, FeatureType::LineString, { emptyLine }, properties },
{ {}, FeatureType::LineString, { emptyLine }, properties }
};
mbgl::util::mergeLines(input1);
@@ -52,14 +59,14 @@ TEST(MergeLines, SameText) {
TEST(MergeLines, BothEnds) {
// mergeLines handles merge from both ends
std::vector<mbgl::SymbolFeature> input2;
input2.push_back(SymbolFeatureStub { {}, FeatureType::LineString, {{{0, 0}, {1, 0}, {2, 0}}}, {}, aaa, {}, 0 });
input2.push_back(SymbolFeatureStub { {}, FeatureType::LineString, {{{4, 0}, {5, 0}, {6, 0}}}, {}, aaa, {}, 0 });
input2.push_back(SymbolFeatureStub { {}, FeatureType::LineString, {{{2, 0}, {3, 0}, {4, 0}}}, {}, aaa, {}, 0 });
input2.push_back(SymbolFeatureStub { {}, FeatureType::LineString, {{{0, 0}, {1, 0}, {2, 0}}}, properties, aaa, {}, 0 });
input2.push_back(SymbolFeatureStub { {}, FeatureType::LineString, {{{4, 0}, {5, 0}, {6, 0}}}, properties, aaa, {}, 0 });
input2.push_back(SymbolFeatureStub { {}, FeatureType::LineString, {{{2, 0}, {3, 0}, {4, 0}}}, properties, aaa, {}, 0 });
const std::vector<StubGeometryTileFeature> expected2 = {
{ {}, FeatureType::LineString, {{{0, 0}, {1, 0}, {2, 0}, {3, 0}, {4, 0}, {5, 0}, {6, 0}}}, {} },
{ {}, FeatureType::LineString, {{}}, {} },
{ {}, FeatureType::LineString, {{}}, {} }
{ {}, FeatureType::LineString, {{{0, 0}, {1, 0}, {2, 0}, {3, 0}, {4, 0}, {5, 0}, {6, 0}}}, properties },
{ {}, FeatureType::LineString, { emptyLine }, properties },
{ {}, FeatureType::LineString, { emptyLine }, properties }
};
mbgl::util::mergeLines(input2);
@@ -72,14 +79,14 @@ TEST(MergeLines, BothEnds) {
TEST(MergeLines, CircularLines) {
// mergeLines handles circular lines
std::vector<mbgl::SymbolFeature> input3;
input3.push_back(SymbolFeatureStub { {}, FeatureType::LineString, {{{0, 0}, {1, 0}, {2, 0}}}, {}, aaa, {}, 0 });
input3.push_back(SymbolFeatureStub { {}, FeatureType::LineString, {{{2, 0}, {3, 0}, {4, 0}}}, {}, aaa, {}, 0 });
input3.push_back(SymbolFeatureStub { {}, FeatureType::LineString, {{{4, 0}, {0, 0}}}, {}, aaa, {}, 0 });
input3.push_back(SymbolFeatureStub { {}, FeatureType::LineString, {{{0, 0}, {1, 0}, {2, 0}}}, properties, aaa, {}, 0 });
input3.push_back(SymbolFeatureStub { {}, FeatureType::LineString, {{{2, 0}, {3, 0}, {4, 0}}}, properties, aaa, {}, 0 });
input3.push_back(SymbolFeatureStub { {}, FeatureType::LineString, {{{4, 0}, {0, 0}}}, properties, aaa, {}, 0 });
const std::vector<StubGeometryTileFeature> expected3 = {
{ {}, FeatureType::LineString, {{{0, 0}, {1, 0}, {2, 0}, {3, 0}, {4, 0}, {0, 0}}}, {} },
{ {}, FeatureType::LineString, {{}}, {} },
{ {}, FeatureType::LineString, {{}}, {} }
{ {}, FeatureType::LineString, {{{0, 0}, {1, 0}, {2, 0}, {3, 0}, {4, 0}, {0, 0}}}, properties },
{ {}, FeatureType::LineString, { emptyLine }, properties },
{ {}, FeatureType::LineString, { emptyLine }, properties }
};
mbgl::util::mergeLines(input3);
@@ -91,9 +98,9 @@ TEST(MergeLines, CircularLines) {
TEST(MergeLines, EmptyOuterGeometry) {
std::vector<mbgl::SymbolFeature> input;
input.push_back(SymbolFeatureStub { {}, FeatureType::LineString, {}, {}, aaa, {}, 0 });
input.push_back(SymbolFeatureStub { {}, FeatureType::LineString, {}, properties, aaa, {}, 0 });
const std::vector<StubGeometryTileFeature> expected = { { {}, FeatureType::LineString, {}, {} } };
const std::vector<StubGeometryTileFeature> expected = { { {}, FeatureType::LineString, {}, properties } };
mbgl::util::mergeLines(input);
@@ -102,9 +109,9 @@ TEST(MergeLines, EmptyOuterGeometry) {
TEST(MergeLines, EmptyInnerGeometry) {
std::vector<mbgl::SymbolFeature> input;
input.push_back(SymbolFeatureStub { {}, FeatureType::LineString, {{}}, {}, aaa, {}, 0 });
input.push_back(SymbolFeatureStub { {}, FeatureType::LineString, {}, properties, aaa, {}, 0 });
const std::vector<StubGeometryTileFeature> expected = { { {}, FeatureType::LineString, {{}}, {} } };
const std::vector<StubGeometryTileFeature> expected = { { {}, FeatureType::LineString, {}, properties } };
mbgl::util::mergeLines(input);