Remove various workarounds for Windows compiler

joto · joto · commit 83af3efe76fa · 2021-11-23T14:01:21.000+01:00
They are not needed any more.
diff --git a/include/osmium/geom/geos.hpp b/include/osmium/geom/geos.hpp
@@ -70,20 +70,13 @@ DEALINGS IN THE SOFTWARE.
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
+#include <exception>
 #include <iterator>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
-// MSVC doesn't support throw_with_nested yet
-#ifdef _MSC_VER
-# define THROW throw
-#else
-# include <exception>
-# define THROW std::throw_with_nested
-#endif
-
 namespace osmium {
 
     struct geos_geometry_error : public geometry_error {
@@ -145,7 +138,7 @@ namespace osmium {
                     try {
                         return point_type{m_geos_factory->createPoint(geos::geom::Coordinate{xy.x, xy.y})};
                     } catch (const geos::util::GEOSException& e) {
-                        THROW(osmium::geos_geometry_error(e.what()));
+                        std::throw_with_nested(osmium::geos_geometry_error(e.what()));
                     }
                 }
 
@@ -155,23 +148,23 @@ namespace osmium {
                     try {
                         m_coordinate_sequence.reset(m_geos_factory->getCoordinateSequenceFactory()->create(static_cast<std::size_t>(0), 2));
                     } catch (const geos::util::GEOSException& e) {
-                        THROW(osmium::geos_geometry_error(e.what()));
+                        std::throw_with_nested(osmium::geos_geometry_error(e.what()));
                     }
                 }
 
                 void linestring_add_location(const osmium::geom::Coordinates& xy) {
                     try {
                         m_coordinate_sequence->add(geos::geom::Coordinate{xy.x, xy.y});
                     } catch (const geos::util::GEOSException& e) {
-                        THROW(osmium::geos_geometry_error(e.what()));
+                        std::throw_with_nested(osmium::geos_geometry_error(e.what()));
                     }
                 }
 
                 linestring_type linestring_finish(std::size_t /* num_points */) {
                     try {
                         return linestring_type{m_geos_factory->createLineString(m_coordinate_sequence.release())};
                     } catch (const geos::util::GEOSException& e) {
-                        THROW(osmium::geos_geometry_error(e.what()));
+                        std::throw_with_nested(osmium::geos_geometry_error(e.what()));
                     }
                 }
 
@@ -195,47 +188,47 @@ namespace osmium {
                         m_polygons.emplace_back(m_geos_factory->createPolygon(m_rings[0].release(), inner_rings));
                         m_rings.clear();
                     } catch (const geos::util::GEOSException& e) {
-                        THROW(osmium::geos_geometry_error(e.what()));
+                        std::throw_with_nested(osmium::geos_geometry_error(e.what()));
                     }
                 }
 
                 void multipolygon_outer_ring_start() {
                     try {
                         m_coordinate_sequence.reset(m_geos_factory->getCoordinateSequenceFactory()->create(static_cast<std::size_t>(0), 2));
                     } catch (const geos::util::GEOSException& e) {
-                        THROW(osmium::geos_geometry_error(e.what()));
+                        std::throw_with_nested(osmium::geos_geometry_error(e.what()));
                     }
                 }
 
                 void multipolygon_outer_ring_finish() {
                     try {
                         m_rings.emplace_back(m_geos_factory->createLinearRing(m_coordinate_sequence.release()));
                     } catch (const geos::util::GEOSException& e) {
-                        THROW(osmium::geos_geometry_error(e.what()));
+                        std::throw_with_nested(osmium::geos_geometry_error(e.what()));
                     }
                 }
 
                 void multipolygon_inner_ring_start() {
                     try {
                         m_coordinate_sequence.reset(m_geos_factory->getCoordinateSequenceFactory()->create(static_cast<std::size_t>(0), 2));
                     } catch (const geos::util::GEOSException& e) {
-                        THROW(osmium::geos_geometry_error(e.what()));
+                        std::throw_with_nested(osmium::geos_geometry_error(e.what()));
                     }
                 }
 
                 void multipolygon_inner_ring_finish() {
                     try {
                         m_rings.emplace_back(m_geos_factory->createLinearRing(m_coordinate_sequence.release()));
                     } catch (const geos::util::GEOSException& e) {
-                        THROW(osmium::geos_geometry_error(e.what()));
+                        std::throw_with_nested(osmium::geos_geometry_error(e.what()));
                     }
                 }
 
                 void multipolygon_add_location(const osmium::geom::Coordinates& xy) {
                     try {
                         m_coordinate_sequence->add(geos::geom::Coordinate{xy.x, xy.y});
                     } catch (const geos::util::GEOSException& e) {
-                        THROW(osmium::geos_geometry_error(e.what()));
+                        std::throw_with_nested(osmium::geos_geometry_error(e.what()));
                     }
                 }
 
@@ -248,7 +241,7 @@ namespace osmium {
                         m_polygons.clear();
                         return multipolygon_type{m_geos_factory->createMultiPolygon(polygons)};
                     } catch (const geos::util::GEOSException& e) {
-                        THROW(osmium::geos_geometry_error(e.what()));
+                        std::throw_with_nested(osmium::geos_geometry_error(e.what()));
                     }
                 }
 
@@ -264,8 +257,6 @@ namespace osmium {
 
 } // namespace osmium
 
-#undef THROW
-
 #endif
 
 #endif // OSMIUM_GEOM_GEOS_HPP
diff --git a/test/data-tests/testdata-xml.cpp b/test/data-tests/testdata-xml.cpp
@@ -368,8 +368,6 @@ TEST_CASE("Reading OSM XML 140: Using Reader") {
 
         REQUIRE(S_(uc) == t["unicode_xml"]);
 
-// workaround for missing support for u8 string literals on Windows
-#if !defined(_MSC_VER)
         switch (count) {
             case 1:
                 REQUIRE(S_(uc) == S_(u8"a"));
@@ -389,7 +387,6 @@ TEST_CASE("Reading OSM XML 140: Using Reader") {
             default:
                 REQUIRE(false); // should not be here
         }
-#endif
     }
     REQUIRE(count == 5);
 }
diff --git a/test/t/io/test_output_utils.cpp b/test/t/io/test_output_utils.cpp
@@ -87,14 +87,11 @@ TEST_CASE("UTF8 encoding: encode characters that are special in OPL") {
     REQUIRE(out == "%20%%0a%%2c%%3d%%40%");
 }
 
-// workaround for missing support for u8 string literals on Windows
-#if !defined(_MSC_VER)
 TEST_CASE("UTF8 encoding: encode multibyte character") {
     std::string out;
     osmium::io::detail::append_utf8_encoded_string(out, u8cast(u8"\u30dc_\U0001d11e_\U0001f6eb"));
     REQUIRE(out == "%30dc%_%1d11e%_%1f6eb%");
 }
-#endif
 
 TEST_CASE("html encoding does not encode normal characters") {
     const char* s = "abc123,.-";

Original file line number	Diff line number	Diff line change
`@@ -70,20 +70,13 @@ DEALINGS IN THE SOFTWARE.`
`70`	`70`	`#include <algorithm>`
`71`	`71`	`#include <cassert>`
`72`	`72`	`#include <cstddef>`
	`73`	`+#include <exception>`
`73`	`74`	`#include <iterator>`
`74`	`75`	`#include <memory>`
`75`	`76`	`#include <string>`
`76`	`77`	`#include <utility>`
`77`	`78`	`#include <vector>`
`78`	`79`
`79`		`-// MSVC doesn't support throw_with_nested yet`
`80`		`-#ifdef _MSC_VER`
`81`		`-# define THROW throw`
`82`		`-#else`
`83`		`-# include <exception>`
`84`		`-# define THROW std::throw_with_nested`
`85`		`-#endif`
`86`		`-`
`87`	`80`	`namespace osmium {`
`88`	`81`
`89`	`82`	`struct geos_geometry_error : public geometry_error {`
`@@ -145,7 +138,7 @@ namespace osmium {`
`145`	`138`	`try {`
`146`	`139`	`return point_type{m_geos_factory->createPoint(geos::geom::Coordinate{xy.x, xy.y})};`
`147`	`140`	`} catch (const geos::util::GEOSException& e) {`
`148`		`- THROW(osmium::geos_geometry_error(e.what()));`
	`141`	`+ std::throw_with_nested(osmium::geos_geometry_error(e.what()));`
`149`	`142`	`}`
`150`	`143`	`}`
`151`	`144`
`@@ -155,23 +148,23 @@ namespace osmium {`
`155`	`148`	`try {`
`156`	`149`	`m_coordinate_sequence.reset(m_geos_factory->getCoordinateSequenceFactory()->create(static_cast<std::size_t>(0), 2));`
`157`	`150`	`} catch (const geos::util::GEOSException& e) {`
`158`		`- THROW(osmium::geos_geometry_error(e.what()));`
	`151`	`+ std::throw_with_nested(osmium::geos_geometry_error(e.what()));`
`159`	`152`	`}`
`160`	`153`	`}`
`161`	`154`
`162`	`155`	`void linestring_add_location(const osmium::geom::Coordinates& xy) {`
`163`	`156`	`try {`
`164`	`157`	`m_coordinate_sequence->add(geos::geom::Coordinate{xy.x, xy.y});`
`165`	`158`	`} catch (const geos::util::GEOSException& e) {`
`166`		`- THROW(osmium::geos_geometry_error(e.what()));`
	`159`	`+ std::throw_with_nested(osmium::geos_geometry_error(e.what()));`
`167`	`160`	`}`
`168`	`161`	`}`
`169`	`162`
`170`	`163`	`linestring_type linestring_finish(std::size_t /* num_points */) {`
`171`	`164`	`try {`
`172`	`165`	`return linestring_type{m_geos_factory->createLineString(m_coordinate_sequence.release())};`
`173`	`166`	`} catch (const geos::util::GEOSException& e) {`
`174`		`- THROW(osmium::geos_geometry_error(e.what()));`
	`167`	`+ std::throw_with_nested(osmium::geos_geometry_error(e.what()));`
`175`	`168`	`}`
`176`	`169`	`}`
`177`	`170`
`@@ -195,47 +188,47 @@ namespace osmium {`
`195`	`188`	`m_polygons.emplace_back(m_geos_factory->createPolygon(m_rings[0].release(), inner_rings));`
`196`	`189`	`m_rings.clear();`
`197`	`190`	`} catch (const geos::util::GEOSException& e) {`
`198`		`- THROW(osmium::geos_geometry_error(e.what()));`
	`191`	`+ std::throw_with_nested(osmium::geos_geometry_error(e.what()));`
`199`	`192`	`}`
`200`	`193`	`}`
`201`	`194`
`202`	`195`	`void multipolygon_outer_ring_start() {`
`203`	`196`	`try {`
`204`	`197`	`m_coordinate_sequence.reset(m_geos_factory->getCoordinateSequenceFactory()->create(static_cast<std::size_t>(0), 2));`
`205`	`198`	`} catch (const geos::util::GEOSException& e) {`
`206`		`- THROW(osmium::geos_geometry_error(e.what()));`
	`199`	`+ std::throw_with_nested(osmium::geos_geometry_error(e.what()));`
`207`	`200`	`}`
`208`	`201`	`}`
`209`	`202`
`210`	`203`	`void multipolygon_outer_ring_finish() {`
`211`	`204`	`try {`
`212`	`205`	`m_rings.emplace_back(m_geos_factory->createLinearRing(m_coordinate_sequence.release()));`
`213`	`206`	`} catch (const geos::util::GEOSException& e) {`
`214`		`- THROW(osmium::geos_geometry_error(e.what()));`
	`207`	`+ std::throw_with_nested(osmium::geos_geometry_error(e.what()));`
`215`	`208`	`}`
`216`	`209`	`}`
`217`	`210`
`218`	`211`	`void multipolygon_inner_ring_start() {`
`219`	`212`	`try {`
`220`	`213`	`m_coordinate_sequence.reset(m_geos_factory->getCoordinateSequenceFactory()->create(static_cast<std::size_t>(0), 2));`
`221`	`214`	`} catch (const geos::util::GEOSException& e) {`
`222`		`- THROW(osmium::geos_geometry_error(e.what()));`
	`215`	`+ std::throw_with_nested(osmium::geos_geometry_error(e.what()));`
`223`	`216`	`}`
`224`	`217`	`}`
`225`	`218`
`226`	`219`	`void multipolygon_inner_ring_finish() {`
`227`	`220`	`try {`
`228`	`221`	`m_rings.emplace_back(m_geos_factory->createLinearRing(m_coordinate_sequence.release()));`
`229`	`222`	`} catch (const geos::util::GEOSException& e) {`
`230`		`- THROW(osmium::geos_geometry_error(e.what()));`
	`223`	`+ std::throw_with_nested(osmium::geos_geometry_error(e.what()));`
`231`	`224`	`}`
`232`	`225`	`}`
`233`	`226`
`234`	`227`	`void multipolygon_add_location(const osmium::geom::Coordinates& xy) {`
`235`	`228`	`try {`
`236`	`229`	`m_coordinate_sequence->add(geos::geom::Coordinate{xy.x, xy.y});`
`237`	`230`	`} catch (const geos::util::GEOSException& e) {`
`238`		`- THROW(osmium::geos_geometry_error(e.what()));`
	`231`	`+ std::throw_with_nested(osmium::geos_geometry_error(e.what()));`
`239`	`232`	`}`
`240`	`233`	`}`
`241`	`234`
`@@ -248,7 +241,7 @@ namespace osmium {`
`248`	`241`	`m_polygons.clear();`
`249`	`242`	`return multipolygon_type{m_geos_factory->createMultiPolygon(polygons)};`
`250`	`243`	`} catch (const geos::util::GEOSException& e) {`
`251`		`- THROW(osmium::geos_geometry_error(e.what()));`
	`244`	`+ std::throw_with_nested(osmium::geos_geometry_error(e.what()));`
`252`	`245`	`}`
`253`	`246`	`}`
`254`	`247`
`@@ -264,8 +257,6 @@ namespace osmium {`
`264`	`257`
`265`	`258`	`} // namespace osmium`
`266`	`259`
`267`		`-#undef THROW`
`268`		`-`
`269`	`260`	`#endif`
`270`	`261`
`271`	`262`	`#endif // OSMIUM_GEOM_GEOS_HPP`
Original file line number	Diff line number	Diff line change
`@@ -368,8 +368,6 @@ TEST_CASE("Reading OSM XML 140: Using Reader") {`
`368`	`368`
`369`	`369`	`REQUIRE(S_(uc) == t["unicode_xml"]);`
`370`	`370`
`371`		`-// workaround for missing support for u8 string literals on Windows`
`372`		`-#if !defined(_MSC_VER)`
`373`	`371`	`switch (count) {`
`374`	`372`	`case 1:`
`375`	`373`	`REQUIRE(S_(uc) == S_(u8"a"));`
`@@ -389,7 +387,6 @@ TEST_CASE("Reading OSM XML 140: Using Reader") {`
`389`	`387`	`default:`
`390`	`388`	`REQUIRE(false); // should not be here`
`391`	`389`	`}`
`392`		`-#endif`
`393`	`390`	`}`
`394`	`391`	`REQUIRE(count == 5);`
`395`	`392`	`}`
Original file line number	Diff line number	Diff line change
`@@ -87,14 +87,11 @@ TEST_CASE("UTF8 encoding: encode characters that are special in OPL") {`
`87`	`87`	`REQUIRE(out == "%20%%0a%%2c%%3d%%40%");`
`88`	`88`	`}`
`89`	`89`
`90`		`-// workaround for missing support for u8 string literals on Windows`
`91`		`-#if !defined(_MSC_VER)`
`92`	`90`	`TEST_CASE("UTF8 encoding: encode multibyte character") {`
`93`	`91`	`std::string out;`
`94`	`92`	`osmium::io::detail::append_utf8_encoded_string(out, u8cast(u8"\u30dc_\U0001d11e_\U0001f6eb"));`
`95`	`93`	`REQUIRE(out == "%30dc%_%1d11e%_%1f6eb%");`
`96`	`94`	`}`
`97`		`-#endif`
`98`	`95`
`99`	`96`	`TEST_CASE("html encoding does not encode normal characters") {`
`100`	`97`	`const char* s = "abc123,.-";`