Open-Harbor/osrm-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

bump osmium version

Browse Source
This commit is contained in:
Dennis Luxen 2014-12-17 11:19:08 +01:00
parent 40ff7ad999
commit 3dddd16ec7
47 changed files with 2620 additions and 2251 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
third_party/osmium/area/detail/segment_list.hpp vendored
View File

@ -70,11 +70,11 @@ namespace osmium {
~SegmentList() = default; ~SegmentList() = default;
SegmentList(const SegmentList& other) = delete; SegmentList(const SegmentList&) = delete;
SegmentList(SegmentList&& other) = delete; SegmentList(SegmentList&&) = delete;
SegmentList& operator=(const SegmentList& other) = delete; SegmentList& operator=(const SegmentList&) = delete;
SegmentList& operator=(SegmentList&& other) = delete; SegmentList& operator=(SegmentList&&) = delete;
/// The number of segments in the list. /// The number of segments in the list.
size_t size() const noexcept { size_t size() const noexcept {

5
third_party/osmium/area/multipolygon_collector.hpp vendored
View File

@ -86,8 +86,9 @@ namespace osmium {
void flush_output_buffer() { void flush_output_buffer() {
if (this->callback()) { if (this->callback()) {
this->callback()(m_output_buffer); osmium::memory::Buffer buffer(initial_output_buffer_size);
m_output_buffer.clear(); std::swap(buffer, m_output_buffer);
this->callback()(std::move(buffer));
} }
} }

192
third_party/osmium/area/problem_reporter_exception.hpp vendored
View File

@ -1,96 +1,96 @@
#ifndef OSMIUM_AREA_PROBLEM_REPORTER_EXCEPTION_HPP #ifndef OSMIUM_AREA_PROBLEM_REPORTER_EXCEPTION_HPP
#define OSMIUM_AREA_PROBLEM_REPORTER_EXCEPTION_HPP #define OSMIUM_AREA_PROBLEM_REPORTER_EXCEPTION_HPP
/* /*
This file is part of Osmium (http://osmcode.org/libosmium). This file is part of Osmium (http://osmcode.org/libosmium).
Copyright 2014 Jochen Topf <jochen@topf.org> and others (see README). Copyright 2014 Jochen Topf <jochen@topf.org> and others (see README).
Boost Software License - Version 1.0 - August 17th, 2003 Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute, this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following: do so, all subject to the following:
The copyright notices in the Software and this entire statement, including The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer, the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by works are solely in the form of machine-executable object code generated by
a source language processor. a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE. DEALINGS IN THE SOFTWARE.
*/ */
#include <sstream> #include <sstream>
#include <stdexcept> #include <stdexcept>
#include <osmium/area/problem_reporter_stream.hpp> #include <osmium/area/problem_reporter_stream.hpp>
#include <osmium/osm/location.hpp> #include <osmium/osm/location.hpp>
#include <osmium/osm/types.hpp> #include <osmium/osm/types.hpp>
namespace osmium { namespace osmium {
namespace area { namespace area {
class ProblemReporterException : public ProblemReporterStream { class ProblemReporterException : public ProblemReporterStream {
std::stringstream m_sstream; std::stringstream m_sstream;
public: public:
ProblemReporterException() : ProblemReporterException() :
ProblemReporterStream(m_sstream) { ProblemReporterStream(m_sstream) {
} }
virtual ~ProblemReporterException() = default; virtual ~ProblemReporterException() = default;
void report_duplicate_node(osmium::object_id_type node_id1, osmium::object_id_type node_id2, osmium::Location location) override { void report_duplicate_node(osmium::object_id_type node_id1, osmium::object_id_type node_id2, osmium::Location location) override {
m_sstream.str(); m_sstream.str();
ProblemReporterStream::report_duplicate_node(node_id1, node_id2, location); ProblemReporterStream::report_duplicate_node(node_id1, node_id2, location);
throw std::runtime_error(m_sstream.str()); throw std::runtime_error(m_sstream.str());
} }
void report_intersection(osmium::object_id_type way1_id, osmium::Location way1_seg_start, osmium::Location way1_seg_end, void report_intersection(osmium::object_id_type way1_id, osmium::Location way1_seg_start, osmium::Location way1_seg_end,
osmium::object_id_type way2_id, osmium::Location way2_seg_start, osmium::Location way2_seg_end, osmium::Location intersection) override { osmium::object_id_type way2_id, osmium::Location way2_seg_start, osmium::Location way2_seg_end, osmium::Location intersection) override {
m_sstream.str(); m_sstream.str();
ProblemReporterStream::report_intersection(way1_id, way1_seg_start, way1_seg_end, way2_id, way2_seg_start, way2_seg_end, intersection); ProblemReporterStream::report_intersection(way1_id, way1_seg_start, way1_seg_end, way2_id, way2_seg_start, way2_seg_end, intersection);
throw std::runtime_error(m_sstream.str()); throw std::runtime_error(m_sstream.str());
} }
void report_ring_not_closed(osmium::Location end1, osmium::Location end2) override { void report_ring_not_closed(osmium::Location end1, osmium::Location end2) override {
m_sstream.str(); m_sstream.str();
ProblemReporterStream::report_ring_not_closed(end1, end2); ProblemReporterStream::report_ring_not_closed(end1, end2);
throw std::runtime_error(m_sstream.str()); throw std::runtime_error(m_sstream.str());
} }
void report_role_should_be_outer(osmium::object_id_type way_id, osmium::Location seg_start, osmium::Location seg_end) override { void report_role_should_be_outer(osmium::object_id_type way_id, osmium::Location seg_start, osmium::Location seg_end) override {
m_sstream.str(); m_sstream.str();
ProblemReporterStream::report_role_should_be_outer(way_id, seg_start, seg_end); ProblemReporterStream::report_role_should_be_outer(way_id, seg_start, seg_end);
throw std::runtime_error(m_sstream.str()); throw std::runtime_error(m_sstream.str());
} }
void report_role_should_be_inner(osmium::object_id_type way_id, osmium::Location seg_start, osmium::Location seg_end) override { void report_role_should_be_inner(osmium::object_id_type way_id, osmium::Location seg_start, osmium::Location seg_end) override {
m_sstream.str(); m_sstream.str();
ProblemReporterStream::report_role_should_be_inner(way_id, seg_start, seg_end); ProblemReporterStream::report_role_should_be_inner(way_id, seg_start, seg_end);
throw std::runtime_error(m_sstream.str()); throw std::runtime_error(m_sstream.str());
} }
}; // class ProblemReporterException }; // class ProblemReporterException
} // namespace area } // namespace area
} // namespace osmium } // namespace osmium
#endif // OSMIUM_AREA_PROBLEM_REPORTER_EXCEPTION_HPP #endif // OSMIUM_AREA_PROBLEM_REPORTER_EXCEPTION_HPP

134
third_party/osmium/diff_handler.hpp vendored
View File

@ -1,67 +1,67 @@
#ifndef OSMIUM_DIFF_HANDLER_HPP #ifndef OSMIUM_DIFF_HANDLER_HPP
#define OSMIUM_DIFF_HANDLER_HPP #define OSMIUM_DIFF_HANDLER_HPP
/* /*
This file is part of Osmium (http://osmcode.org/libosmium). This file is part of Osmium (http://osmcode.org/libosmium).
Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README). Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README).
Boost Software License - Version 1.0 - August 17th, 2003 Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute, this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following: do so, all subject to the following:
The copyright notices in the Software and this entire statement, including The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer, the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by works are solely in the form of machine-executable object code generated by
a source language processor. a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE. DEALINGS IN THE SOFTWARE.
*/ */
#include <osmium/osm/diff_object.hpp> #include <osmium/osm/diff_object.hpp>
namespace osmium { namespace osmium {
/** /**
* @brief Osmium diff handlers provide access to differences between OSM object versions * @brief Osmium diff handlers provide access to differences between OSM object versions
*/ */
namespace diff_handler { namespace diff_handler {
class DiffHandler { class DiffHandler {
public: public:
DiffHandler() { DiffHandler() {
} }
void node(const osmium::DiffNode&) const { void node(const osmium::DiffNode&) const {
} }
void way(const osmium::DiffWay&) const { void way(const osmium::DiffWay&) const {
} }
void relation(const osmium::DiffRelation&) const { void relation(const osmium::DiffRelation&) const {
} }
}; // class DiffHandler }; // class DiffHandler
} // namespace diff_handler } // namespace diff_handler
} // namespace osmium } // namespace osmium
#endif // OSMIUM_DIFF_HANDLER_HPP #endif // OSMIUM_DIFF_HANDLER_HPP

8
third_party/osmium/diff_iterator.hpp vendored
View File

@ -81,11 +81,11 @@ namespace osmium {
m_end(end) { m_end(end) {
} }
DiffIterator(const DiffIterator& other) = default; DiffIterator(const DiffIterator&) = default;
DiffIterator& operator=(const DiffIterator& other) = default; DiffIterator& operator=(const DiffIterator&) = default;
DiffIterator(DiffIterator&& other) = default; DiffIterator(DiffIterator&&) = default;
DiffIterator& operator=(DiffIterator&& other) = default; DiffIterator& operator=(DiffIterator&&) = default;
DiffIterator& operator++() { DiffIterator& operator++() {
m_prev = std::move(m_curr); m_prev = std::move(m_curr);

208
third_party/osmium/diff_visitor.hpp vendored
View File

@ -1,104 +1,104 @@
#ifndef OSMIUM_DIFF_VISITOR_HPP #ifndef OSMIUM_DIFF_VISITOR_HPP
#define OSMIUM_DIFF_VISITOR_HPP #define OSMIUM_DIFF_VISITOR_HPP
/* /*
This file is part of Osmium (http://osmcode.org/libosmium). This file is part of Osmium (http://osmcode.org/libosmium).
Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README). Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README).
Boost Software License - Version 1.0 - August 17th, 2003 Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute, this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following: do so, all subject to the following:
The copyright notices in the Software and this entire statement, including The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer, the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by works are solely in the form of machine-executable object code generated by
a source language processor. a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE. DEALINGS IN THE SOFTWARE.
*/ */
#include <osmium/diff_iterator.hpp> #include <osmium/diff_iterator.hpp>
#include <osmium/io/input_iterator.hpp> #include <osmium/io/input_iterator.hpp>
#include <osmium/memory/buffer.hpp> #include <osmium/memory/buffer.hpp>
#include <osmium/osm/diff_object.hpp> #include <osmium/osm/diff_object.hpp>
#include <osmium/osm/item_type.hpp> #include <osmium/osm/item_type.hpp>
namespace osmium { namespace osmium {
namespace detail { namespace detail {
template <class THandler> template <class THandler>
inline void apply_diff_iterator_recurse(const osmium::DiffObject& diff, THandler& handler) { inline void apply_diff_iterator_recurse(const osmium::DiffObject& diff, THandler& handler) {
switch (diff.type()) { switch (diff.type()) {
case osmium::item_type::node: case osmium::item_type::node:
handler.node(static_cast<const osmium::DiffNode&>(diff)); handler.node(static_cast<const osmium::DiffNode&>(diff));
break; break;
case osmium::item_type::way: case osmium::item_type::way:
handler.way(static_cast<const osmium::DiffWay&>(diff)); handler.way(static_cast<const osmium::DiffWay&>(diff));
break; break;
case osmium::item_type::relation: case osmium::item_type::relation:
handler.relation(static_cast<const osmium::DiffRelation&>(diff)); handler.relation(static_cast<const osmium::DiffRelation&>(diff));
break; break;
default: default:
throw osmium::unknown_type(); throw osmium::unknown_type();
} }
} }
template <class THandler, class ...TRest> template <class THandler, class ...TRest>
inline void apply_diff_iterator_recurse(const osmium::DiffObject& diff, THandler& handler, TRest&... more) { inline void apply_diff_iterator_recurse(const osmium::DiffObject& diff, THandler& handler, TRest&... more) {
apply_diff_iterator_recurse(diff, handler); apply_diff_iterator_recurse(diff, handler);
apply_diff_iterator_recurse(diff, more...); apply_diff_iterator_recurse(diff, more...);
} }
} // namespace detail } // namespace detail
template <class TIterator, class ...THandlers> template <class TIterator, class ...THandlers>
inline void apply_diff(TIterator it, TIterator end, THandlers&... handlers) { inline void apply_diff(TIterator it, TIterator end, THandlers&... handlers) {
typedef osmium::DiffIterator<TIterator> diff_iterator; typedef osmium::DiffIterator<TIterator> diff_iterator;
diff_iterator dit(it, end); diff_iterator dit(it, end);
diff_iterator dend(end, end); diff_iterator dend(end, end);
for (; dit != dend; ++dit) { for (; dit != dend; ++dit) {
detail::apply_diff_iterator_recurse(*dit, handlers...); detail::apply_diff_iterator_recurse(*dit, handlers...);
} }
} }
class OSMObject; class OSMObject;
template <class TSource, class ...THandlers> template <class TSource, class ...THandlers>
inline void apply_diff(TSource& source, THandlers&... handlers) { inline void apply_diff(TSource& source, THandlers&... handlers) {
apply_diff(osmium::io::InputIterator<TSource, osmium::OSMObject> {source}, apply_diff(osmium::io::InputIterator<TSource, osmium::OSMObject> {source},
osmium::io::InputIterator<TSource, osmium::OSMObject> {}, osmium::io::InputIterator<TSource, osmium::OSMObject> {},
handlers...); handlers...);
} }
template <class ...THandlers> template <class ...THandlers>
inline void apply_diff(osmium::memory::Buffer& buffer, THandlers&... handlers) { inline void apply_diff(osmium::memory::Buffer& buffer, THandlers&... handlers) {
apply_diff(buffer.begin(), buffer.end(), handlers...); apply_diff(buffer.begin(), buffer.end(), handlers...);
} }
template <class ...THandlers> template <class ...THandlers>
inline void apply_diff(const osmium::memory::Buffer& buffer, THandlers&... handlers) { inline void apply_diff(const osmium::memory::Buffer& buffer, THandlers&... handlers) {
apply_diff(buffer.cbegin(), buffer.cend(), handlers...); apply_diff(buffer.cbegin(), buffer.cend(), handlers...);
} }
} // namespace osmium } // namespace osmium
#endif // OSMIUM_DIFF_VISITOR_HPP #endif // OSMIUM_DIFF_VISITOR_HPP

131
third_party/osmium/experimental/flex_reader.hpp vendored Normal file
View File

@ -0,0 +1,131 @@
#ifndef OSMIUM_EXPERIMENTAL_FLEX_READER_HPP
#define OSMIUM_EXPERIMENTAL_FLEX_READER_HPP
/*
This file is part of Osmium (http://osmcode.org/libosmium).
Copyright 2014 Jochen Topf <jochen@topf.org> and others (see README).
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:
The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/
#include <osmium/handler/node_locations_for_ways.hpp>
#include <osmium/visitor.hpp>
#include <osmium/area/multipolygon_collector.hpp>
#include <osmium/area/assembler.hpp>
namespace osmium {
/**
* Experimental code that is not "officially" supported.
*/
namespace experimental {
template <class TLocationHandler>
class FlexReader {
bool m_with_areas;
osmium::osm_entity_bits::type m_entities;
typename TLocationHandler::index_pos_type m_index_pos;
typename TLocationHandler::index_neg_type m_index_neg;
TLocationHandler m_location_handler;
osmium::io::Reader m_reader;
osmium::area::Assembler::config_type m_assembler_config;
osmium::area::MultipolygonCollector<osmium::area::Assembler> m_collector;
public:
explicit FlexReader(const osmium::io::File& file, osmium::osm_entity_bits::type entities = osmium::osm_entity_bits::nwr) :
m_with_areas(entities & osmium::osm_entity_bits::area),
m_entities((entities & ~osmium::osm_entity_bits::area) | (m_with_areas ? osmium::osm_entity_bits::node | osmium::osm_entity_bits::way : osmium::osm_entity_bits::nothing)),
m_index_pos(),
m_index_neg(),
m_location_handler(m_index_pos, m_index_neg),
m_reader(file, m_entities),
m_assembler_config(),
m_collector(m_assembler_config)
{
m_location_handler.ignore_errors();
if (m_with_areas) {
osmium::io::Reader reader(file, osmium::osm_entity_bits::relation);
m_collector.read_relations(reader);
reader.close();
}
}
explicit FlexReader(const std::string& filename, osmium::osm_entity_bits::type entities = osmium::osm_entity_bits::nwr) :
FlexReader(osmium::io::File(filename), entities) {
}
explicit FlexReader(const char* filename, osmium::osm_entity_bits::type entities = osmium::osm_entity_bits::nwr) :
FlexReader(osmium::io::File(filename), entities) {
}
std::vector<osmium::memory::Buffer> read() {
std::vector<osmium::memory::Buffer> buffers;
osmium::memory::Buffer buffer = m_reader.read();
if (buffer) {
buffers.push_back(std::move(buffer));
if (m_with_areas) {
osmium::apply(buffers[0], m_location_handler, m_collector.handler([&buffers](osmium::memory::Buffer&& area_buffer) {
buffers.push_back(std::move(area_buffer));
}));
} else if (m_entities & (osmium::osm_entity_bits::node | osmium::osm_entity_bits::way)) {
osmium::apply(buffers[0], m_location_handler);
}
}
return buffers;
}
osmium::io::Header header() const {
return m_reader.header();
}
void close() {
return m_reader.close();
}
bool eof() const {
return m_reader.eof();
}
const osmium::area::MultipolygonCollector<osmium::area::Assembler>& collector() const {
return m_collector;
}
}; // class FlexReader
} // namespace experimental
} // namespace osmium
#endif // OSMIUM_EXPERIMENTAL_FLEX_READER_HPP

114
third_party/osmium/geom/relations.hpp vendored
View File

@ -1,57 +1,57 @@
#ifndef OSMIUM_GEOM_RELATIONS_HPP #ifndef OSMIUM_GEOM_RELATIONS_HPP
#define OSMIUM_GEOM_RELATIONS_HPP #define OSMIUM_GEOM_RELATIONS_HPP
/* /*
This file is part of Osmium (http://osmcode.org/libosmium). This file is part of Osmium (http://osmcode.org/libosmium).
Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README). Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README).
Boost Software License - Version 1.0 - August 17th, 2003 Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute, this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following: do so, all subject to the following:
The copyright notices in the Software and this entire statement, including The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer, the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by works are solely in the form of machine-executable object code generated by
a source language processor. a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE. DEALINGS IN THE SOFTWARE.
*/ */
#include <osmium/osm/box.hpp> #include <osmium/osm/box.hpp>
#include <osmium/osm/location.hpp> #include <osmium/osm/location.hpp>
namespace osmium { namespace osmium {
namespace geom { namespace geom {
/** /**
* Check whether one geometry contains another. * Check whether one geometry contains another.
*/ */
inline bool contains(const osmium::Box& a, const osmium::Box& b) { inline bool contains(const osmium::Box& a, const osmium::Box& b) {
return ((a.bottom_left().x() >= b.bottom_left().x()) && return ((a.bottom_left().x() >= b.bottom_left().x()) &&
(a.top_right().x() <= b.top_right().x()) && (a.top_right().x() <= b.top_right().x()) &&
(a.bottom_left().y() >= b.bottom_left().y()) && (a.bottom_left().y() >= b.bottom_left().y()) &&
(a.top_right().y() <= b.top_right().y())); (a.top_right().y() <= b.top_right().y()));
} }
} // namespace geom } // namespace geom
} // namespace osmium } // namespace osmium
#endif // OSMIUM_GEOM_RELATIONS_HPP #endif // OSMIUM_GEOM_RELATIONS_HPP

202
third_party/osmium/handler.hpp vendored
View File

@ -1,101 +1,101 @@
#ifndef OSMIUM_HANDLER_HPP #ifndef OSMIUM_HANDLER_HPP
#define OSMIUM_HANDLER_HPP #define OSMIUM_HANDLER_HPP
/* /*
This file is part of Osmium (http://osmcode.org/libosmium). This file is part of Osmium (http://osmcode.org/libosmium).
Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README). Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README).
Boost Software License - Version 1.0 - August 17th, 2003 Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute, this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following: do so, all subject to the following:
The copyright notices in the Software and this entire statement, including The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer, the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by works are solely in the form of machine-executable object code generated by
a source language processor. a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE. DEALINGS IN THE SOFTWARE.
*/ */
namespace osmium { namespace osmium {
class OSMObject; class OSMObject;
class Node; class Node;
class Way; class Way;
class Relation; class Relation;
class Area; class Area;
class Changeset; class Changeset;
class TagList; class TagList;
class WayNodeList; class WayNodeList;
class RelationMemberList; class RelationMemberList;
class OuterRing; class OuterRing;
class InnerRing; class InnerRing;
/** /**
* @brief Osmium handlers provide callbacks for OSM objects * @brief Osmium handlers provide callbacks for OSM objects
*/ */
namespace handler { namespace handler {
class Handler { class Handler {
public: public:
void osm_object(const osmium::OSMObject&) const { void osm_object(const osmium::OSMObject&) const {
} }
void node(const osmium::Node&) const { void node(const osmium::Node&) const {
} }
void way(const osmium::Way&) const { void way(const osmium::Way&) const {
} }
void relation(const osmium::Relation&) const { void relation(const osmium::Relation&) const {
} }
void area(const osmium::Area&) const { void area(const osmium::Area&) const {
} }
void changeset(const osmium::Changeset&) const { void changeset(const osmium::Changeset&) const {
} }
void tag_list(const osmium::TagList&) const { void tag_list(const osmium::TagList&) const {
} }
void way_node_list(const osmium::WayNodeList&) const { void way_node_list(const osmium::WayNodeList&) const {
} }
void relation_member_list(const osmium::RelationMemberList&) const { void relation_member_list(const osmium::RelationMemberList&) const {
} }
void outer_ring(const osmium::OuterRing&) const { void outer_ring(const osmium::OuterRing&) const {
} }
void inner_ring(const osmium::InnerRing&) const { void inner_ring(const osmium::InnerRing&) const {
} }
void flush() const { void flush() const {
} }
}; // class Handler }; // class Handler
} // namspace handler } // namspace handler
} // namespace osmium } // namespace osmium
#endif // OSMIUM_HANDLER_HPP #endif // OSMIUM_HANDLER_HPP

222
third_party/osmium/handler/disk_store.hpp vendored
View File

@ -1,111 +1,111 @@
#ifndef OSMIUM_HANDLER_DISK_STORE_HPP #ifndef OSMIUM_HANDLER_DISK_STORE_HPP
#define OSMIUM_HANDLER_DISK_STORE_HPP #define OSMIUM_HANDLER_DISK_STORE_HPP
/* /*
This file is part of Osmium (http://osmcode.org/libosmium). This file is part of Osmium (http://osmcode.org/libosmium).
Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README). Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README).
Boost Software License - Version 1.0 - August 17th, 2003 Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute, this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following: do so, all subject to the following:
The copyright notices in the Software and this entire statement, including The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer, the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by works are solely in the form of machine-executable object code generated by
a source language processor. a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE. DEALINGS IN THE SOFTWARE.
*/ */
#include <cstddef> #include <cstddef>
#include <osmium/handler.hpp> #include <osmium/handler.hpp>
#include <osmium/index/map.hpp> #include <osmium/index/map.hpp>
#include <osmium/io/detail/read_write.hpp> #include <osmium/io/detail/read_write.hpp>
#include <osmium/memory/buffer.hpp> #include <osmium/memory/buffer.hpp>
#include <osmium/memory/item_iterator.hpp> #include <osmium/memory/item_iterator.hpp>
#include <osmium/osm/node.hpp> #include <osmium/osm/node.hpp>
#include <osmium/osm/relation.hpp> #include <osmium/osm/relation.hpp>
#include <osmium/osm/types.hpp> #include <osmium/osm/types.hpp>
#include <osmium/osm/way.hpp> #include <osmium/osm/way.hpp>
#include <osmium/visitor.hpp> #include <osmium/visitor.hpp>
namespace osmium { namespace osmium {
namespace handler { namespace handler {
/** /**
* *
* Note: This handler will only work if either all object IDs are * Note: This handler will only work if either all object IDs are
* positive or all object IDs are negative. * positive or all object IDs are negative.
*/ */
class DiskStore : public osmium::handler::Handler { class DiskStore : public osmium::handler::Handler {
typedef osmium::index::map::Map<unsigned_object_id_type, size_t> offset_index_type; typedef osmium::index::map::Map<unsigned_object_id_type, size_t> offset_index_type;
size_t m_offset = 0; size_t m_offset = 0;
int m_data_fd; int m_data_fd;
offset_index_type& m_node_index; offset_index_type& m_node_index;
offset_index_type& m_way_index; offset_index_type& m_way_index;
offset_index_type& m_relation_index; offset_index_type& m_relation_index;
public: public:
explicit DiskStore(int data_fd, offset_index_type& node_index, offset_index_type& way_index, offset_index_type& relation_index) : explicit DiskStore(int data_fd, offset_index_type& node_index, offset_index_type& way_index, offset_index_type& relation_index) :
m_data_fd(data_fd), m_data_fd(data_fd),
m_node_index(node_index), m_node_index(node_index),
m_way_index(way_index), m_way_index(way_index),
m_relation_index(relation_index) { m_relation_index(relation_index) {
} }
DiskStore(const DiskStore&) = delete; DiskStore(const DiskStore&) = delete;
DiskStore& operator=(const DiskStore&) = delete; DiskStore& operator=(const DiskStore&) = delete;
~DiskStore() noexcept = default; ~DiskStore() noexcept = default;
void node(const osmium::Node& node) { void node(const osmium::Node& node) {
m_node_index.set(node.positive_id(), m_offset); m_node_index.set(node.positive_id(), m_offset);
m_offset += node.byte_size(); m_offset += node.byte_size();
} }
void way(const osmium::Way& way) { void way(const osmium::Way& way) {
m_way_index.set(way.positive_id(), m_offset); m_way_index.set(way.positive_id(), m_offset);
m_offset += way.byte_size(); m_offset += way.byte_size();
} }
void relation(const osmium::Relation& relation) { void relation(const osmium::Relation& relation) {
m_relation_index.set(relation.positive_id(), m_offset); m_relation_index.set(relation.positive_id(), m_offset);
m_offset += relation.byte_size(); m_offset += relation.byte_size();
} }
// XXX // XXX
void operator()(const osmium::memory::Buffer& buffer) { void operator()(const osmium::memory::Buffer& buffer) {
osmium::io::detail::reliable_write(m_data_fd, buffer.data(), buffer.committed()); osmium::io::detail::reliable_write(m_data_fd, buffer.data(), buffer.committed());
osmium::apply(buffer.begin(), buffer.end(), *this); osmium::apply(buffer.begin(), buffer.end(), *this);
} }
}; // class DiskStore }; // class DiskStore
} // namespace handler } // namespace handler
} // namespace osmium } // namespace osmium
#endif // OSMIUM_HANDLER_DISK_STORE_HPP #endif // OSMIUM_HANDLER_DISK_STORE_HPP

7
third_party/osmium/handler/node_locations_for_ways.hpp vendored
View File

@ -67,6 +67,13 @@ namespace osmium {
static_assert(std::is_base_of<osmium::index::map::Map<osmium::unsigned_object_id_type, osmium::Location>, TStorageNegIDs>::value, static_assert(std::is_base_of<osmium::index::map::Map<osmium::unsigned_object_id_type, osmium::Location>, TStorageNegIDs>::value,
"Index class must be derived from osmium::index::map::Map<osmium::unsigned_object_id_type, osmium::Location>"); "Index class must be derived from osmium::index::map::Map<osmium::unsigned_object_id_type, osmium::Location>");
public:
typedef TStoragePosIDs index_pos_type;
typedef TStorageNegIDs index_neg_type;
private:
/// Object that handles the actual storage of the node locations (with positive IDs). /// Object that handles the actual storage of the node locations (with positive IDs).
TStoragePosIDs& m_storage_pos; TStoragePosIDs& m_storage_pos;

212
third_party/osmium/handler/object_relations.hpp vendored
View File

@ -1,106 +1,106 @@
#ifndef OSMIUM_HANDLER_OBJECT_RELATIONS_HPP #ifndef OSMIUM_HANDLER_OBJECT_RELATIONS_HPP
#define OSMIUM_HANDLER_OBJECT_RELATIONS_HPP #define OSMIUM_HANDLER_OBJECT_RELATIONS_HPP
/* /*
This file is part of Osmium (http://osmcode.org/libosmium). This file is part of Osmium (http://osmcode.org/libosmium).
Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README). Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README).
Boost Software License - Version 1.0 - August 17th, 2003 Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute, this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following: do so, all subject to the following:
The copyright notices in the Software and this entire statement, including The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer, the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by works are solely in the form of machine-executable object code generated by
a source language processor. a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE. DEALINGS IN THE SOFTWARE.
*/ */
#include <osmium/handler.hpp> #include <osmium/handler.hpp>
#include <osmium/index/multimap.hpp> #include <osmium/index/multimap.hpp>
#include <osmium/osm/node_ref.hpp> #include <osmium/osm/node_ref.hpp>
#include <osmium/osm/item_type.hpp> #include <osmium/osm/item_type.hpp>
#include <osmium/osm/relation.hpp> #include <osmium/osm/relation.hpp>
#include <osmium/osm/types.hpp> #include <osmium/osm/types.hpp>
#include <osmium/osm/way.hpp> #include <osmium/osm/way.hpp>
namespace osmium { namespace osmium {
namespace handler { namespace handler {
/** /**
* *
* Note: This handler will only work if either all object IDs are * Note: This handler will only work if either all object IDs are
* positive or all object IDs are negative. * positive or all object IDs are negative.
*/ */
class ObjectRelations : public osmium::handler::Handler { class ObjectRelations : public osmium::handler::Handler {
typedef osmium::index::multimap::Multimap<unsigned_object_id_type, unsigned_object_id_type> index_type; typedef osmium::index::multimap::Multimap<unsigned_object_id_type, unsigned_object_id_type> index_type;
index_type& m_index_n2w; index_type& m_index_n2w;
index_type& m_index_n2r; index_type& m_index_n2r;
index_type& m_index_w2r; index_type& m_index_w2r;
index_type& m_index_r2r; index_type& m_index_r2r;
public: public:
explicit ObjectRelations(index_type& n2w, index_type& n2r, index_type& w2r, index_type& r2r) : explicit ObjectRelations(index_type& n2w, index_type& n2r, index_type& w2r, index_type& r2r) :
m_index_n2w(n2w), m_index_n2w(n2w),
m_index_n2r(n2r), m_index_n2r(n2r),
m_index_w2r(w2r), m_index_w2r(w2r),
m_index_r2r(r2r) { m_index_r2r(r2r) {
} }
ObjectRelations(const ObjectRelations&) = delete; ObjectRelations(const ObjectRelations&) = delete;
ObjectRelations& operator=(const ObjectRelations&) = delete; ObjectRelations& operator=(const ObjectRelations&) = delete;
~ObjectRelations() noexcept = default; ~ObjectRelations() noexcept = default;
void way(const osmium::Way& way) { void way(const osmium::Way& way) {
for (const auto& node_ref : way.nodes()) { for (const auto& node_ref : way.nodes()) {
m_index_n2w.set(node_ref.positive_ref(), way.positive_id()); m_index_n2w.set(node_ref.positive_ref(), way.positive_id());
} }
} }
void relation(const osmium::Relation& relation) { void relation(const osmium::Relation& relation) {
for (const auto& member : relation.members()) { for (const auto& member : relation.members()) {
switch (member.type()) { switch (member.type()) {
case osmium::item_type::node: case osmium::item_type::node:
m_index_n2r.set(member.positive_ref(), relation.positive_id()); m_index_n2r.set(member.positive_ref(), relation.positive_id());
break; break;
case osmium::item_type::way: case osmium::item_type::way:
m_index_w2r.set(member.positive_ref(), relation.positive_id()); m_index_w2r.set(member.positive_ref(), relation.positive_id());
break; break;
case osmium::item_type::relation: case osmium::item_type::relation:
m_index_r2r.set(member.positive_ref(), relation.positive_id()); m_index_r2r.set(member.positive_ref(), relation.positive_id());
break; break;
default: default:
break; break;
} }
} }
} }
}; // class ObjectRelations }; // class ObjectRelations
} // namespace handler } // namespace handler
} // namespace osmium } // namespace osmium
#endif // OSMIUM_HANDLER_OBJECT_RELATIONS_HPP #endif // OSMIUM_HANDLER_OBJECT_RELATIONS_HPP

174
third_party/osmium/index/map/dummy.hpp vendored
View File

@ -1,87 +1,87 @@
#ifndef OSMIUM_INDEX_MAP_DUMMY_HPP #ifndef OSMIUM_INDEX_MAP_DUMMY_HPP
#define OSMIUM_INDEX_MAP_DUMMY_HPP #define OSMIUM_INDEX_MAP_DUMMY_HPP
/* /*
This file is part of Osmium (http://osmcode.org/libosmium). This file is part of Osmium (http://osmcode.org/libosmium).
Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README). Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README).
Boost Software License - Version 1.0 - August 17th, 2003 Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute, this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following: do so, all subject to the following:
The copyright notices in the Software and this entire statement, including The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer, the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by works are solely in the form of machine-executable object code generated by
a source language processor. a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE. DEALINGS IN THE SOFTWARE.
*/ */
#include <cstddef> #include <cstddef>
#include <osmium/index/map.hpp> #include <osmium/index/map.hpp>
namespace osmium { namespace osmium {
namespace index { namespace index {
namespace map { namespace map {
/** /**
* Pseudo map. * Pseudo map.
* Use this class if you don't need a map, but you * Use this class if you don't need a map, but you
* need an object that behaves like one. * need an object that behaves like one.
*/ */
template <typename TId, typename TValue> template <typename TId, typename TValue>
class Dummy : public osmium::index::map::Map<TId, TValue> { class Dummy : public osmium::index::map::Map<TId, TValue> {
public: public:
Dummy() = default; Dummy() = default;
~Dummy() override final = default; ~Dummy() override final = default;
void set(const TId, const TValue) override final { void set(const TId, const TValue) override final {
// intentionally left blank // intentionally left blank
} }
const TValue get(const TId id) const override final { const TValue get(const TId id) const override final {
not_found_error(id); not_found_error(id);
} }
size_t size() const override final { size_t size() const override final {
return 0; return 0;
} }
size_t used_memory() const override final { size_t used_memory() const override final {
return 0; return 0;
} }
void clear() override final { void clear() override final {
} }
}; // class Dummy }; // class Dummy
} // namespace map } // namespace map
} // namespace index } // namespace index
} // namespace osmium } // namespace osmium
#endif // OSMIUM_INDEX_MAP_DUMMY_HPP #endif // OSMIUM_INDEX_MAP_DUMMY_HPP

122
third_party/osmium/index/map/mmap_vector_anon.hpp vendored
View File

@ -1,61 +1,61 @@
#ifndef OSMIUM_INDEX_MAP_MMAP_VECTOR_ANON_HPP #ifndef OSMIUM_INDEX_MAP_MMAP_VECTOR_ANON_HPP
#define OSMIUM_INDEX_MAP_MMAP_VECTOR_ANON_HPP #define OSMIUM_INDEX_MAP_MMAP_VECTOR_ANON_HPP
/* /*
This file is part of Osmium (http://osmcode.org/libosmium). This file is part of Osmium (http://osmcode.org/libosmium).
Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README). Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README).
Boost Software License - Version 1.0 - August 17th, 2003 Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute, this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following: do so, all subject to the following:
The copyright notices in the Software and this entire statement, including The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer, the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by works are solely in the form of machine-executable object code generated by
a source language processor. a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE. DEALINGS IN THE SOFTWARE.
*/ */
#ifdef __linux__ #ifdef __linux__
#include <osmium/index/map/vector.hpp> #include <osmium/index/map/vector.hpp>
#include <osmium/index/detail/mmap_vector_anon.hpp> #include <osmium/index/detail/mmap_vector_anon.hpp>
namespace osmium { namespace osmium {
namespace index { namespace index {
namespace map { namespace map {
template <typename TId, typename TValue> template <typename TId, typename TValue>
using DenseMapMmap = VectorBasedDenseMap<osmium::detail::mmap_vector_anon<TValue>, TId, TValue>; using DenseMapMmap = VectorBasedDenseMap<osmium::detail::mmap_vector_anon<TValue>, TId, TValue>;
template <typename TId, typename TValue> template <typename TId, typename TValue>
using SparseMapMmap = VectorBasedSparseMap<TId, TValue, osmium::detail::mmap_vector_anon>; using SparseMapMmap = VectorBasedSparseMap<TId, TValue, osmium::detail::mmap_vector_anon>;
} // namespace map } // namespace map
} // namespace index } // namespace index
} // namespace osmium } // namespace osmium
#endif // __linux__ #endif // __linux__
#endif // OSMIUM_INDEX_MAP_MMAP_VECTOR_ANON_HPP #endif // OSMIUM_INDEX_MAP_MMAP_VECTOR_ANON_HPP

114
third_party/osmium/index/map/mmap_vector_file.hpp vendored
View File

@ -1,57 +1,57 @@
#ifndef OSMIUM_INDEX_MAP_MMAP_VECTOR_FILE_HPP #ifndef OSMIUM_INDEX_MAP_MMAP_VECTOR_FILE_HPP
#define OSMIUM_INDEX_MAP_MMAP_VECTOR_FILE_HPP #define OSMIUM_INDEX_MAP_MMAP_VECTOR_FILE_HPP
/* /*
This file is part of Osmium (http://osmcode.org/libosmium). This file is part of Osmium (http://osmcode.org/libosmium).
Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README). Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README).
Boost Software License - Version 1.0 - August 17th, 2003 Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute, this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following: do so, all subject to the following:
The copyright notices in the Software and this entire statement, including The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer, the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by works are solely in the form of machine-executable object code generated by
a source language processor. a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE. DEALINGS IN THE SOFTWARE.
*/ */
#include <osmium/index/map/vector.hpp> #include <osmium/index/map/vector.hpp>
#include <osmium/index/detail/mmap_vector_file.hpp> #include <osmium/index/detail/mmap_vector_file.hpp>
namespace osmium { namespace osmium {
namespace index { namespace index {
namespace map { namespace map {
template <typename TId, typename TValue> template <typename TId, typename TValue>
using DenseMapFile = VectorBasedDenseMap<osmium::detail::mmap_vector_file<TValue>, TId, TValue>; using DenseMapFile = VectorBasedDenseMap<osmium::detail::mmap_vector_file<TValue>, TId, TValue>;
template <typename TId, typename TValue> template <typename TId, typename TValue>
using SparseMapFile = VectorBasedSparseMap<TId, TValue, osmium::detail::mmap_vector_file>; using SparseMapFile = VectorBasedSparseMap<TId, TValue, osmium::detail::mmap_vector_file>;
} // namespace map } // namespace map
} // namespace index } // namespace index
} // namespace osmium } // namespace osmium
#endif // OSMIUM_INDEX_MAP_MMAP_VECTOR_FILE_HPP #endif // OSMIUM_INDEX_MAP_MMAP_VECTOR_FILE_HPP

116
third_party/osmium/index/multimap/mmap_vector_anon.hpp vendored
View File

@ -1,58 +1,58 @@
#ifndef OSMIUM_INDEX_MULTIMAP_MMAP_VECTOR_ANON_HPP #ifndef OSMIUM_INDEX_MULTIMAP_MMAP_VECTOR_ANON_HPP
#define OSMIUM_INDEX_MULTIMAP_MMAP_VECTOR_ANON_HPP #define OSMIUM_INDEX_MULTIMAP_MMAP_VECTOR_ANON_HPP
/* /*
This file is part of Osmium (http://osmcode.org/libosmium). This file is part of Osmium (http://osmcode.org/libosmium).
Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README). Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README).
Boost Software License - Version 1.0 - August 17th, 2003 Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute, this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following: do so, all subject to the following:
The copyright notices in the Software and this entire statement, including The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer, the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by works are solely in the form of machine-executable object code generated by
a source language processor. a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE. DEALINGS IN THE SOFTWARE.
*/ */
#ifdef __linux__ #ifdef __linux__
#include <osmium/index/multimap/vector.hpp> #include <osmium/index/multimap/vector.hpp>
#include <osmium/index/detail/mmap_vector_anon.hpp> #include <osmium/index/detail/mmap_vector_anon.hpp>
namespace osmium { namespace osmium {
namespace index { namespace index {
namespace multimap { namespace multimap {
template <typename TId, typename TValue> template <typename TId, typename TValue>
using SparseMultimapMmap = VectorBasedSparseMultimap<TId, TValue, osmium::detail::mmap_vector_anon>; using SparseMultimapMmap = VectorBasedSparseMultimap<TId, TValue, osmium::detail::mmap_vector_anon>;
} // namespace multimap } // namespace multimap
} // namespace index } // namespace index
} // namespace osmium } // namespace osmium
#endif // __linux__ #endif // __linux__
#endif // OSMIUM_INDEX_MULTIMAP_MMAP_VECTOR_ANON_HPP #endif // OSMIUM_INDEX_MULTIMAP_MMAP_VECTOR_ANON_HPP

108
third_party/osmium/index/multimap/mmap_vector_file.hpp vendored
View File

@ -1,54 +1,54 @@
#ifndef OSMIUM_INDEX_MULTIMAP_MMAP_VECTOR_FILE_HPP #ifndef OSMIUM_INDEX_MULTIMAP_MMAP_VECTOR_FILE_HPP
#define OSMIUM_INDEX_MULTIMAP_MMAP_VECTOR_FILE_HPP #define OSMIUM_INDEX_MULTIMAP_MMAP_VECTOR_FILE_HPP
/* /*
This file is part of Osmium (http://osmcode.org/libosmium). This file is part of Osmium (http://osmcode.org/libosmium).
Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README). Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README).
Boost Software License - Version 1.0 - August 17th, 2003 Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute, this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following: do so, all subject to the following:
The copyright notices in the Software and this entire statement, including The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer, the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by works are solely in the form of machine-executable object code generated by
a source language processor. a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE. DEALINGS IN THE SOFTWARE.
*/ */
#include <osmium/index/multimap/vector.hpp> #include <osmium/index/multimap/vector.hpp>
#include <osmium/index/detail/mmap_vector_file.hpp> #include <osmium/index/detail/mmap_vector_file.hpp>
namespace osmium { namespace osmium {
namespace index { namespace index {
namespace multimap { namespace multimap {
template <typename TId, typename TValue> template <typename TId, typename TValue>
using SparseMultimapFile = VectorBasedSparseMultimap<TId, TValue, osmium::detail::mmap_vector_file>; using SparseMultimapFile = VectorBasedSparseMultimap<TId, TValue, osmium::detail::mmap_vector_file>;
} // namespace multimap } // namespace multimap
} // namespace index } // namespace index
} // namespace osmium } // namespace osmium
#endif // OSMIUM_INDEX_MULTIMAP_MMAP_VECTOR_FILE_HPP #endif // OSMIUM_INDEX_MULTIMAP_MMAP_VECTOR_FILE_HPP

10
third_party/osmium/io/detail/opl_output_format.hpp vendored
View File

@ -189,8 +189,8 @@ namespace osmium {
OPLOutputBlock(const OPLOutputBlock&) = delete; OPLOutputBlock(const OPLOutputBlock&) = delete;
OPLOutputBlock& operator=(const OPLOutputBlock&) = delete; OPLOutputBlock& operator=(const OPLOutputBlock&) = delete;
OPLOutputBlock(OPLOutputBlock&& other) = default; OPLOutputBlock(OPLOutputBlock&&) = default;
OPLOutputBlock& operator=(OPLOutputBlock&& other) = default; OPLOutputBlock& operator=(OPLOutputBlock&&) = default;
std::string operator()() { std::string operator()() {
osmium::apply(m_input_buffer.cbegin(), m_input_buffer.cend(), *this); osmium::apply(m_input_buffer.cbegin(), m_input_buffer.cend(), *this);
@ -282,11 +282,7 @@ namespace osmium {
} }
void write_buffer(osmium::memory::Buffer&& buffer) override final { void write_buffer(osmium::memory::Buffer&& buffer) override final {
osmium::thread::SharedPtrWrapper<OPLOutputBlock> output_block(std::move(buffer)); m_output_queue.push(osmium::thread::Pool::instance().submit(OPLOutputBlock{std::move(buffer)}));
m_output_queue.push(osmium::thread::Pool::instance().submit(std::move(output_block)));
while (m_output_queue.size() > 10) {
std::this_thread::sleep_for(std::chrono::milliseconds(100)); // XXX
}
} }
void close() override final { void close() override final {

312
third_party/osmium/io/detail/output_format.hpp vendored
View File

@ -1,156 +1,156 @@
#ifndef OSMIUM_IO_DETAIL_OUTPUT_FORMAT_HPP #ifndef OSMIUM_IO_DETAIL_OUTPUT_FORMAT_HPP
#define OSMIUM_IO_DETAIL_OUTPUT_FORMAT_HPP #define OSMIUM_IO_DETAIL_OUTPUT_FORMAT_HPP
/* /*
This file is part of Osmium (http://osmcode.org/libosmium). This file is part of Osmium (http://osmcode.org/libosmium).
Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README). Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README).
Boost Software License - Version 1.0 - August 17th, 2003 Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute, this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following: do so, all subject to the following:
The copyright notices in the Software and this entire statement, including The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer, the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by works are solely in the form of machine-executable object code generated by
a source language processor. a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE. DEALINGS IN THE SOFTWARE.
*/ */
#include <functional> #include <functional>
#include <future> #include <future>
#include <map> #include <map>
#include <memory> #include <memory>
#include <stdexcept> #include <stdexcept>
#include <string> #include <string>
#include <utility> #include <utility>
#include <osmium/io/file.hpp> #include <osmium/io/file.hpp>
#include <osmium/io/file_format.hpp> #include <osmium/io/file_format.hpp>
#include <osmium/io/header.hpp> #include <osmium/io/header.hpp>
#include <osmium/thread/queue.hpp> #include <osmium/thread/queue.hpp>
namespace osmium { namespace osmium {
namespace memory { namespace memory {
class Buffer; class Buffer;
} }
namespace io { namespace io {
namespace detail { namespace detail {
typedef osmium::thread::Queue<std::future<std::string>> data_queue_type; typedef osmium::thread::Queue<std::future<std::string>> data_queue_type;
/** /**
* Virtual base class for all classes writing OSM files in different * Virtual base class for all classes writing OSM files in different
* formats. * formats.
* *
* Do not use this class or derived classes directly. Use the * Do not use this class or derived classes directly. Use the
* osmium::io::Writer class instead. * osmium::io::Writer class instead.
*/ */
class OutputFormat { class OutputFormat {
protected: protected:
osmium::io::File m_file; osmium::io::File m_file;
data_queue_type& m_output_queue; data_queue_type& m_output_queue;
public: public:
explicit OutputFormat(const osmium::io::File& file, data_queue_type& output_queue) : explicit OutputFormat(const osmium::io::File& file, data_queue_type& output_queue) :
m_file(file), m_file(file),
m_output_queue(output_queue) { m_output_queue(output_queue) {
} }
OutputFormat(const OutputFormat&) = delete; OutputFormat(const OutputFormat&) = delete;
OutputFormat(OutputFormat&&) = delete; OutputFormat(OutputFormat&&) = delete;
OutputFormat& operator=(const OutputFormat&) = delete; OutputFormat& operator=(const OutputFormat&) = delete;
OutputFormat& operator=(OutputFormat&&) = delete; OutputFormat& operator=(OutputFormat&&) = delete;
virtual ~OutputFormat() { virtual ~OutputFormat() {
} }
virtual void write_header(const osmium::io::Header&) { virtual void write_header(const osmium::io::Header&) {
} }
virtual void write_buffer(osmium::memory::Buffer&&) = 0; virtual void write_buffer(osmium::memory::Buffer&&) = 0;
virtual void close() = 0; virtual void close() = 0;
}; // class OutputFormat }; // class OutputFormat
/** /**
* This factory class is used to create objects that write OSM data * This factory class is used to create objects that write OSM data
* into a specified output format. * into a specified output format.
* *
* Do not use this class directly. Instead use the osmium::io::Writer * Do not use this class directly. Instead use the osmium::io::Writer
* class. * class.
*/ */
class OutputFormatFactory { class OutputFormatFactory {
public: public:
typedef std::function<osmium::io::detail::OutputFormat*(const osmium::io::File&, data_queue_type&)> create_output_type; typedef std::function<osmium::io::detail::OutputFormat*(const osmium::io::File&, data_queue_type&)> create_output_type;
private: private:
typedef std::map<osmium::io::file_format, create_output_type> map_type; typedef std::map<osmium::io::file_format, create_output_type> map_type;
map_type m_callbacks; map_type m_callbacks;
OutputFormatFactory() : OutputFormatFactory() :
m_callbacks() { m_callbacks() {
} }
public: public:
static OutputFormatFactory& instance() { static OutputFormatFactory& instance() {
static OutputFormatFactory factory; static OutputFormatFactory factory;
return factory; return factory;
} }
bool register_output_format(osmium::io::file_format format, create_output_type create_function) { bool register_output_format(osmium::io::file_format format, create_output_type create_function) {
if (! m_callbacks.insert(map_type::value_type(format, create_function)).second) { if (! m_callbacks.insert(map_type::value_type(format, create_function)).second) {
return false; return false;
} }
return true; return true;
} }
std::unique_ptr<osmium::io::detail::OutputFormat> create_output(const osmium::io::File& file, data_queue_type& output_queue) { std::unique_ptr<osmium::io::detail::OutputFormat> create_output(const osmium::io::File& file, data_queue_type& output_queue) {
file.check(); file.check();
auto it = m_callbacks.find(file.format()); auto it = m_callbacks.find(file.format());
if (it != m_callbacks.end()) { if (it != m_callbacks.end()) {
return std::unique_ptr<osmium::io::detail::OutputFormat>((it->second)(file, output_queue)); return std::unique_ptr<osmium::io::detail::OutputFormat>((it->second)(file, output_queue));
} }
throw std::runtime_error(std::string("Support for output format '") + as_string(file.format()) + "' not compiled into this binary."); throw std::runtime_error(std::string("Support for output format '") + as_string(file.format()) + "' not compiled into this binary.");
} }
}; // class OutputFormatFactory }; // class OutputFormatFactory
} // namespace detail } // namespace detail
} // namespace io } // namespace io
} // namespace osmium } // namespace osmium
#endif // OSMIUM_IO_DETAIL_OUTPUT_FORMAT_HPP #endif // OSMIUM_IO_DETAIL_OUTPUT_FORMAT_HPP

17
third_party/osmium/io/detail/pbf.hpp vendored
View File

@ -46,6 +46,7 @@ DEALINGS IN THE SOFTWARE.
# include <winsock2.h> # include <winsock2.h>
#endif #endif
#include <osmium/io/error.hpp>
#include <osmium/osm/item_type.hpp> #include <osmium/osm/item_type.hpp>
namespace osmium { namespace osmium {
@ -78,6 +79,22 @@ namespace osmium {
} }
} }
/**
* Exception thrown when there was a problem with parsing the PBF format of
* a file.
*/
struct pbf_error : public io_error {
pbf_error(const std::string& what) :
io_error(std::string("PBF error: ") + what) {
}
pbf_error(const char* what) :
io_error(std::string("PBF error: ") + what) {
}
}; // struct pbf_error
} // namespace osmium } // namespace osmium
#endif // OSMIUM_IO_DETAIL_PBF_HPP #endif // OSMIUM_IO_DETAIL_PBF_HPP

564
third_party/osmium/io/detail/pbf_input_format.hpp vendored
View File

@ -47,14 +47,14 @@ DEALINGS IN THE SOFTWARE.
#include <stdexcept> #include <stdexcept>
#include <string> #include <string>
#include <thread> #include <thread>
#include <type_traits>
#include <osmium/builder/osm_object_builder.hpp>
#include <osmium/io/detail/input_format.hpp> #include <osmium/io/detail/input_format.hpp>
#include <osmium/io/detail/pbf.hpp> // IWYU pragma: export #include <osmium/io/detail/pbf.hpp> // IWYU pragma: export
#include <osmium/io/detail/zlib.hpp> #include <osmium/io/detail/pbf_parser.hpp>
#include <osmium/io/error.hpp>
#include <osmium/io/file.hpp> #include <osmium/io/file.hpp>
#include <osmium/io/file_format.hpp> #include <osmium/io/file_format.hpp>
#include <osmium/io/header.hpp>
#include <osmium/memory/buffer.hpp> #include <osmium/memory/buffer.hpp>
#include <osmium/osm.hpp> #include <osmium/osm.hpp>
#include <osmium/osm/box.hpp> #include <osmium/osm/box.hpp>
@ -62,486 +62,22 @@ DEALINGS IN THE SOFTWARE.
#include <osmium/osm/location.hpp> #include <osmium/osm/location.hpp>
#include <osmium/osm/object.hpp> #include <osmium/osm/object.hpp>
#include <osmium/osm/timestamp.hpp> #include <osmium/osm/timestamp.hpp>
#include <osmium/thread/name.hpp>
#include <osmium/thread/pool.hpp> #include <osmium/thread/pool.hpp>
#include <osmium/thread/queue.hpp> #include <osmium/thread/queue.hpp>
#include <osmium/thread/util.hpp>
#include <osmium/util/cast.hpp> #include <osmium/util/cast.hpp>
#include <osmium/util/config.hpp>
namespace osmium { namespace osmium {
/**
* Exception thrown when there was a problem with parsing the PBF format of
* a file.
*/
struct pbf_error : public io_error {
pbf_error(const std::string& what) :
io_error(std::string("PBF error: ") + what) {
}
pbf_error(const char* what) :
io_error(std::string("PBF error: ") + what) {
}
}; // struct pbf_error
namespace io { namespace io {
class File; class File;
namespace detail { namespace detail {
class PBFPrimitiveBlockParser {
static constexpr size_t initial_buffer_size = 2 * 1024 * 1024;
const void* m_data;
const int m_size;
const OSMPBF::StringTable* m_stringtable;
int64_t m_lon_offset;
int64_t m_lat_offset;
int64_t m_date_factor;
int32_t m_granularity;
osmium::osm_entity_bits::type m_read_types;
osmium::memory::Buffer m_buffer;
PBFPrimitiveBlockParser(const PBFPrimitiveBlockParser&) = delete;
PBFPrimitiveBlockParser(PBFPrimitiveBlockParser&&) = delete;
PBFPrimitiveBlockParser& operator=(const PBFPrimitiveBlockParser&) = delete;
PBFPrimitiveBlockParser& operator=(PBFPrimitiveBlockParser&&) = delete;
public:
explicit PBFPrimitiveBlockParser(const void* data, const int size, osmium::osm_entity_bits::type read_types) :
m_data(data),
m_size(size),
m_stringtable(nullptr),
m_lon_offset(0),
m_lat_offset(0),
m_date_factor(1000),
m_granularity(100),
m_read_types(read_types),
m_buffer(initial_buffer_size) {
}
~PBFPrimitiveBlockParser() = default;
osmium::memory::Buffer operator()() {
OSMPBF::PrimitiveBlock pbf_primitive_block;
if (!pbf_primitive_block.ParseFromArray(m_data, m_size)) {
throw osmium::pbf_error("failed to parse PrimitiveBlock");
}
m_stringtable = &pbf_primitive_block.stringtable();
m_lon_offset = pbf_primitive_block.lon_offset();
m_lat_offset = pbf_primitive_block.lat_offset();
m_date_factor = pbf_primitive_block.date_granularity() / 1000;
m_granularity = pbf_primitive_block.granularity();
for (int i=0; i < pbf_primitive_block.primitivegroup_size(); ++i) {
const OSMPBF::PrimitiveGroup& group = pbf_primitive_block.primitivegroup(i);
if (group.has_dense()) {
if (m_read_types & osmium::osm_entity_bits::node) parse_dense_node_group(group);
} else if (group.ways_size() != 0) {
if (m_read_types & osmium::osm_entity_bits::way) parse_way_group(group);
} else if (group.relations_size() != 0) {
if (m_read_types & osmium::osm_entity_bits::relation) parse_relation_group(group);
} else if (group.nodes_size() != 0) {
if (m_read_types & osmium::osm_entity_bits::node) parse_node_group(group);
} else {
throw osmium::pbf_error("group of unknown type");
}
}
return std::move(m_buffer);
}
private:
template <class TBuilder, class TPBFObject>
void parse_attributes(TBuilder& builder, const TPBFObject& pbf_object) {
auto& object = builder.object();
object.set_id(pbf_object.id());
if (pbf_object.has_info()) {
object.set_version(static_cast_with_assert<object_version_type>(pbf_object.info().version()))
.set_changeset(static_cast_with_assert<changeset_id_type>(pbf_object.info().changeset()))
.set_timestamp(pbf_object.info().timestamp() * m_date_factor)
.set_uid_from_signed(pbf_object.info().uid());
if (pbf_object.info().has_visible()) {
object.set_visible(pbf_object.info().visible());
}
builder.add_user(m_stringtable->s(static_cast_with_assert<int>(pbf_object.info().user_sid())));
} else {
builder.add_user("", 1);
}
}
void parse_node_group(const OSMPBF::PrimitiveGroup& group) {
for (int i=0; i < group.nodes_size(); ++i) {
osmium::builder::NodeBuilder builder(m_buffer);
const OSMPBF::Node& pbf_node = group.nodes(i);
parse_attributes(builder, pbf_node);
if (builder.object().visible()) {
builder.object().set_location(osmium::Location(
(pbf_node.lon() * m_granularity + m_lon_offset) / (OSMPBF::lonlat_resolution / osmium::Location::coordinate_precision),
(pbf_node.lat() * m_granularity + m_lat_offset) / (OSMPBF::lonlat_resolution / osmium::Location::coordinate_precision)));
}
if (pbf_node.keys_size() > 0) {
osmium::builder::TagListBuilder tl_builder(m_buffer, &builder);
for (int tag=0; tag < pbf_node.keys_size(); ++tag) {
tl_builder.add_tag(m_stringtable->s(static_cast<int>(pbf_node.keys(tag))),
m_stringtable->s(static_cast<int>(pbf_node.vals(tag))));
}
}
m_buffer.commit();
}
}
void parse_way_group(const OSMPBF::PrimitiveGroup& group) {
for (int i=0; i < group.ways_size(); ++i) {
osmium::builder::WayBuilder builder(m_buffer);
const OSMPBF::Way& pbf_way = group.ways(i);
parse_attributes(builder, pbf_way);
if (pbf_way.refs_size() > 0) {
osmium::builder::WayNodeListBuilder wnl_builder(m_buffer, &builder);
int64_t ref = 0;
for (int n=0; n < pbf_way.refs_size(); ++n) {
ref += pbf_way.refs(n);
wnl_builder.add_node_ref(ref);
}
}
if (pbf_way.keys_size() > 0) {
osmium::builder::TagListBuilder tl_builder(m_buffer, &builder);
for (int tag=0; tag < pbf_way.keys_size(); ++tag) {
tl_builder.add_tag(m_stringtable->s(static_cast<int>(pbf_way.keys(tag))),
m_stringtable->s(static_cast<int>(pbf_way.vals(tag))));
}
}
m_buffer.commit();
}
}
void parse_relation_group(const OSMPBF::PrimitiveGroup& group) {
for (int i=0; i < group.relations_size(); ++i) {
osmium::builder::RelationBuilder builder(m_buffer);
const OSMPBF::Relation& pbf_relation = group.relations(i);
parse_attributes(builder, pbf_relation);
if (pbf_relation.types_size() > 0) {
osmium::builder::RelationMemberListBuilder rml_builder(m_buffer, &builder);
int64_t ref = 0;
for (int n=0; n < pbf_relation.types_size(); ++n) {
ref += pbf_relation.memids(n);
rml_builder.add_member(osmpbf_membertype_to_item_type(pbf_relation.types(n)), ref, m_stringtable->s(pbf_relation.roles_sid(n)));
}
}
if (pbf_relation.keys_size() > 0) {
osmium::builder::TagListBuilder tl_builder(m_buffer, &builder);
for (int tag=0; tag < pbf_relation.keys_size(); ++tag) {
tl_builder.add_tag(m_stringtable->s(static_cast<int>(pbf_relation.keys(tag))),
m_stringtable->s(static_cast<int>(pbf_relation.vals(tag))));
}
}
m_buffer.commit();
}
}
int add_tags(const OSMPBF::DenseNodes& dense, int n, osmium::builder::NodeBuilder* builder) {
if (n >= dense.keys_vals_size()) {
return n;
}
if (dense.keys_vals(n) == 0) {
return n+1;
}
osmium::builder::TagListBuilder tl_builder(m_buffer, builder);
while (n < dense.keys_vals_size()) {
int tag_key_pos = dense.keys_vals(n++);
if (tag_key_pos == 0) {
break;
}
tl_builder.add_tag(m_stringtable->s(tag_key_pos),
m_stringtable->s(dense.keys_vals(n)));
++n;
}
return n;
}
void parse_dense_node_group(const OSMPBF::PrimitiveGroup& group) {
int64_t last_dense_id = 0;
int64_t last_dense_latitude = 0;
int64_t last_dense_longitude = 0;
int64_t last_dense_uid = 0;
int64_t last_dense_user_sid = 0;
int64_t last_dense_changeset = 0;
int64_t last_dense_timestamp = 0;
int last_dense_tag = 0;
const OSMPBF::DenseNodes& dense = group.dense();
for (int i=0; i < dense.id_size(); ++i) {
bool visible = true;
last_dense_id += dense.id(i);
last_dense_latitude += dense.lat(i);
last_dense_longitude += dense.lon(i);
if (dense.has_denseinfo()) {
last_dense_changeset += dense.denseinfo().changeset(i);
last_dense_timestamp += dense.denseinfo().timestamp(i);
last_dense_uid += dense.denseinfo().uid(i);
last_dense_user_sid += dense.denseinfo().user_sid(i);
if (dense.denseinfo().visible_size() > 0) {
visible = dense.denseinfo().visible(i);
}
assert(last_dense_changeset >= 0);
assert(last_dense_timestamp >= 0);
assert(last_dense_uid >= -1);
assert(last_dense_user_sid >= 0);
}
osmium::builder::NodeBuilder builder(m_buffer);
osmium::Node& node = builder.object();
node.set_id(last_dense_id);
if (dense.has_denseinfo()) {
auto v = dense.denseinfo().version(i);
assert(v > 0);
node.set_version(static_cast<osmium::object_version_type>(v));
node.set_changeset(static_cast<osmium::changeset_id_type>(last_dense_changeset));
node.set_timestamp(last_dense_timestamp * m_date_factor);
node.set_uid_from_signed(static_cast<osmium::signed_user_id_type>(last_dense_uid));
node.set_visible(visible);
builder.add_user(m_stringtable->s(static_cast<int>(last_dense_user_sid)));
} else {
builder.add_user("", 1);
}
if (visible) {
builder.object().set_location(osmium::Location(
(last_dense_longitude * m_granularity + m_lon_offset) / (OSMPBF::lonlat_resolution / osmium::Location::coordinate_precision),
(last_dense_latitude * m_granularity + m_lat_offset) / (OSMPBF::lonlat_resolution / osmium::Location::coordinate_precision)));
}
last_dense_tag = add_tags(dense, last_dense_tag, &builder);
m_buffer.commit();
}
}
}; // class PBFPrimitiveBlockParser
typedef osmium::thread::Queue<std::future<osmium::memory::Buffer>> queue_type; typedef osmium::thread::Queue<std::future<osmium::memory::Buffer>> queue_type;
class InputQueueReader {
osmium::thread::Queue<std::string>& m_queue;
std::string m_buffer;
public:
InputQueueReader(osmium::thread::Queue<std::string>& queue) :
m_queue(queue) {
}
bool operator()(unsigned char* data, size_t size) {
while (m_buffer.size() < size) {
std::string new_data;
m_queue.wait_and_pop(new_data);
if (new_data.empty()) {
return false;
}
m_buffer += new_data;
}
memcpy(data, m_buffer.data(), size);
m_buffer.erase(0, size);
return true;
}
}; // class InputQueueReader
template <class TDerived>
class BlobParser {
protected:
std::shared_ptr<unsigned char> m_input_buffer;
const int m_size;
const int m_blob_num;
InputQueueReader& m_input_queue_reader;
BlobParser(const int size, const int blob_num, InputQueueReader& input_queue_reader) :
m_input_buffer(new unsigned char[size], [](unsigned char* ptr) { delete[] ptr; }),
m_size(size),
m_blob_num(blob_num),
m_input_queue_reader(input_queue_reader) {
if (size < 0 || size > OSMPBF::max_uncompressed_blob_size) {
throw osmium::pbf_error(std::string("invalid blob size: " + std::to_string(size)));
}
if (! input_queue_reader(m_input_buffer.get(), static_cast<size_t>(size))) {
throw osmium::pbf_error("truncated data (EOF encountered)");
}
}
public:
void doit() {
OSMPBF::Blob pbf_blob;
if (!pbf_blob.ParseFromArray(m_input_buffer.get(), m_size)) {
throw osmium::pbf_error("failed to parse blob");
}
if (pbf_blob.has_raw()) {
static_cast<TDerived*>(this)->handle_blob(pbf_blob.raw());
return;
} else if (pbf_blob.has_zlib_data()) {
auto raw_size = pbf_blob.raw_size();
assert(raw_size >= 0);
assert(raw_size <= OSMPBF::max_uncompressed_blob_size);
std::string unpack_buffer { osmium::io::detail::zlib_uncompress(pbf_blob.zlib_data(), static_cast<unsigned long>(raw_size)) };
static_cast<TDerived*>(this)->handle_blob(unpack_buffer);
return;
} else if (pbf_blob.has_lzma_data()) {
throw osmium::pbf_error("lzma blobs not implemented");
} else {
throw osmium::pbf_error("blob contains no data");
}
}
osmium::memory::Buffer operator()() {
OSMPBF::Blob pbf_blob;
if (!pbf_blob.ParseFromArray(m_input_buffer.get(), m_size)) {
throw osmium::pbf_error("failed to parse blob");
}
if (pbf_blob.has_raw()) {
return static_cast<TDerived*>(this)->handle_blob(pbf_blob.raw());
} else if (pbf_blob.has_zlib_data()) {
auto raw_size = pbf_blob.raw_size();
assert(raw_size >= 0);
assert(raw_size <= OSMPBF::max_uncompressed_blob_size);
std::string unpack_buffer { osmium::io::detail::zlib_uncompress(pbf_blob.zlib_data(), static_cast<unsigned long>(raw_size)) };
return static_cast<TDerived*>(this)->handle_blob(unpack_buffer);
} else if (pbf_blob.has_lzma_data()) {
throw osmium::pbf_error("lzma blobs not implemented");
} else {
throw osmium::pbf_error("blob contains no data");
}
}
}; // class BlobParser;
class HeaderBlobParser : public BlobParser<HeaderBlobParser> {
osmium::io::Header& m_header;
void handle_blob(const std::string& data) {
OSMPBF::HeaderBlock pbf_header_block;
if (!pbf_header_block.ParseFromArray(data.data(), static_cast_with_assert<int>(data.size()))) {
throw osmium::pbf_error("failed to parse HeaderBlock");
}
for (int i=0; i < pbf_header_block.required_features_size(); ++i) {
const std::string& feature = pbf_header_block.required_features(i);
if (feature == "OsmSchema-V0.6") continue;
if (feature == "DenseNodes") {
m_header.set("pbf_dense_nodes", true);
continue;
}
if (feature == "HistoricalInformation") {
m_header.set_has_multiple_object_versions(true);
continue;
}
throw osmium::pbf_error(std::string("required feature not supported: ") + feature);
}
for (int i=0; i < pbf_header_block.optional_features_size(); ++i) {
const std::string& feature = pbf_header_block.optional_features(i);
m_header.set("pbf_optional_feature_" + std::to_string(i), feature);
}
if (pbf_header_block.has_writingprogram()) {
m_header.set("generator", pbf_header_block.writingprogram());
}
if (pbf_header_block.has_bbox()) {
const OSMPBF::HeaderBBox& pbf_bbox = pbf_header_block.bbox();
const int64_t resolution_convert = OSMPBF::lonlat_resolution / osmium::Location::coordinate_precision;
osmium::Box box;
box.extend(osmium::Location(pbf_bbox.left() / resolution_convert, pbf_bbox.bottom() / resolution_convert));
box.extend(osmium::Location(pbf_bbox.right() / resolution_convert, pbf_bbox.top() / resolution_convert));
m_header.add_box(box);
}
if (pbf_header_block.has_osmosis_replication_timestamp()) {
m_header.set("osmosis_replication_timestamp", osmium::Timestamp(pbf_header_block.osmosis_replication_timestamp()).to_iso());
}
if (pbf_header_block.has_osmosis_replication_sequence_number()) {
m_header.set("osmosis_replication_sequence_number", std::to_string(pbf_header_block.osmosis_replication_sequence_number()));
}
if (pbf_header_block.has_osmosis_replication_base_url()) {
m_header.set("osmosis_replication_base_url", pbf_header_block.osmosis_replication_base_url());
}
}
public:
friend class BlobParser<HeaderBlobParser>;
HeaderBlobParser(const int size, InputQueueReader& input_queue_reader, osmium::io::Header& header) :
BlobParser(size, 0, input_queue_reader),
m_header(header) {
}
}; // class HeaderBlobParser
class DataBlobParser : public BlobParser<DataBlobParser> {
osmium::osm_entity_bits::type m_read_types;
osmium::memory::Buffer handle_blob(const std::string& data) {
PBFPrimitiveBlockParser parser(data.data(), static_cast_with_assert<int>(data.size()), m_read_types);
return std::move(parser());
}
public:
friend class BlobParser<DataBlobParser>;
DataBlobParser(const int size, const int blob_num, InputQueueReader& input_queue_reader, osmium::osm_entity_bits::type read_types) :
BlobParser(size, blob_num, input_queue_reader),
m_read_types(read_types) {
}
}; // class DataBlobParser
/** /**
* Class for parsing PBF files. * Class for parsing PBF files.
*/ */
@ -549,25 +85,50 @@ namespace osmium {
bool m_use_thread_pool; bool m_use_thread_pool;
queue_type m_queue; queue_type m_queue;
const size_t m_max_work_queue_size;
const size_t m_max_buffer_queue_size;
std::atomic<bool> m_done; std::atomic<bool> m_done;
std::thread m_reader; std::thread m_reader;
OSMPBF::BlobHeader m_blob_header; osmium::thread::Queue<std::string>& m_input_queue;
InputQueueReader m_input_queue_reader; std::string m_input_buffer;
/** /**
* Read BlobHeader by first reading the size and then the BlobHeader. * Read the given number of bytes from the input queue.
* The BlobHeader contains a type field (which is checked against
* the expected type) and a size field.
* *
* @param expected_type Expected type of data ("OSMHeader" or "OSMData"). * @param size Number of bytes to read
* @returns String with the data
* @throws osmium::pbf_error If size bytes can't be read
*/
std::string read_from_input_queue(size_t size) {
while (m_input_buffer.size() < size) {
std::string new_data;
m_input_queue.wait_and_pop(new_data);
if (new_data.empty()) {
throw osmium::pbf_error("truncated data (EOF encountered)");
}
m_input_buffer += new_data;
}
std::string output { m_input_buffer.substr(size) };
m_input_buffer.resize(size);
std::swap(output, m_input_buffer);
return output;
}
/**
* Read BlobHeader by first reading the size and then the
* BlobHeader. The BlobHeader contains a type field (which is
* checked against the expected type) and a size field.
*
* @param expected_type Expected type of data ("OSMHeader" or
* "OSMData").
* @returns Size of the data read from BlobHeader (0 on EOF). * @returns Size of the data read from BlobHeader (0 on EOF).
*/ */
int read_blob_header(const char* expected_type) { size_t read_blob_header(const char* expected_type) {
uint32_t size_in_network_byte_order; uint32_t size_in_network_byte_order;
if (! m_input_queue_reader(reinterpret_cast<unsigned char*>(&size_in_network_byte_order), sizeof(size_in_network_byte_order))) { try {
std::string input_data = read_from_input_queue(sizeof(size_in_network_byte_order));
size_in_network_byte_order = *reinterpret_cast<const uint32_t*>(input_data.data());
} catch (osmium::pbf_error&) {
return 0; // EOF return 0; // EOF
} }
@ -576,47 +137,33 @@ namespace osmium {
throw osmium::pbf_error("invalid BlobHeader size (> max_blob_header_size)"); throw osmium::pbf_error("invalid BlobHeader size (> max_blob_header_size)");
} }
unsigned char blob_header_buffer[OSMPBF::max_blob_header_size]; OSMPBF::BlobHeader blob_header;
if (! m_input_queue_reader(blob_header_buffer, size)) { if (!blob_header.ParseFromString(read_from_input_queue(size))) {
throw osmium::pbf_error("read error");
}
if (!m_blob_header.ParseFromArray(blob_header_buffer, static_cast<int>(size))) {
throw osmium::pbf_error("failed to parse BlobHeader"); throw osmium::pbf_error("failed to parse BlobHeader");
} }
if (std::strcmp(m_blob_header.type().c_str(), expected_type)) { if (blob_header.type() != expected_type) {
throw osmium::pbf_error("blob does not have expected type (OSMHeader in first blob, OSMData in following blobs)"); throw osmium::pbf_error("blob does not have expected type (OSMHeader in first blob, OSMData in following blobs)");
} }
return m_blob_header.datasize(); return static_cast<size_t>(blob_header.datasize());
} }
void parse_osm_data(osmium::osm_entity_bits::type read_types) { void parse_osm_data(osmium::osm_entity_bits::type read_types) {
osmium::thread::set_thread_name("_osmium_pbf_in"); osmium::thread::set_thread_name("_osmium_pbf_in");
int n=0; int n=0;
while (int size = read_blob_header("OSMData")) { while (auto size = read_blob_header("OSMData")) {
DataBlobParser data_blob_parser(size, n, m_input_queue_reader, read_types);
if (m_use_thread_pool) { if (m_use_thread_pool) {
m_queue.push(osmium::thread::Pool::instance().submit(data_blob_parser)); m_queue.push(osmium::thread::Pool::instance().submit(DataBlobParser{read_from_input_queue(size), read_types}));
// if the work queue is getting too large, wait for a while
while (!m_done && osmium::thread::Pool::instance().queue_size() >= m_max_work_queue_size) {
std::this_thread::sleep_for(std::chrono::milliseconds(10));
}
} else { } else {
std::promise<osmium::memory::Buffer> promise; std::promise<osmium::memory::Buffer> promise;
m_queue.push(promise.get_future()); m_queue.push(promise.get_future());
DataBlobParser data_blob_parser{read_from_input_queue(size), read_types};
promise.set_value(data_blob_parser()); promise.set_value(data_blob_parser());
} }
++n; ++n;
// wait if the backlog of buffers with parsed data is too large
while (!m_done && m_queue.size() > m_max_buffer_queue_size) {
std::this_thread::sleep_for(std::chrono::milliseconds(10));
}
if (m_done) { if (m_done) {
return; return;
} }
@ -635,21 +182,16 @@ namespace osmium {
*/ */
PBFInputFormat(const osmium::io::File& file, osmium::osm_entity_bits::type read_which_entities, osmium::thread::Queue<std::string>& input_queue) : PBFInputFormat(const osmium::io::File& file, osmium::osm_entity_bits::type read_which_entities, osmium::thread::Queue<std::string>& input_queue) :
osmium::io::detail::InputFormat(file, read_which_entities, input_queue), osmium::io::detail::InputFormat(file, read_which_entities, input_queue),
m_use_thread_pool(true), m_use_thread_pool(osmium::config::use_pool_threads_for_pbf_parsing()),
m_queue(), m_queue(20, "pbf_parser_results"), // XXX
m_max_work_queue_size(10), // XXX tune these settings
m_max_buffer_queue_size(20), // XXX tune these settings
m_done(false), m_done(false),
m_input_queue_reader(input_queue) { m_input_queue(input_queue),
m_input_buffer() {
GOOGLE_PROTOBUF_VERIFY_VERSION; GOOGLE_PROTOBUF_VERIFY_VERSION;
// handle OSMHeader // handle OSMHeader
int size = read_blob_header("OSMHeader"); auto size = read_blob_header("OSMHeader");
m_header = parse_header_blob(read_from_input_queue(size));
{
HeaderBlobParser header_blob_parser(size, m_input_queue_reader, m_header);
header_blob_parser.doit();
}
if (m_read_which_entities != osmium::osm_entity_bits::nothing) { if (m_read_which_entities != osmium::osm_entity_bits::nothing) {
m_reader = std::thread(&PBFInputFormat::parse_osm_data, this, m_read_which_entities); m_reader = std::thread(&PBFInputFormat::parse_osm_data, this, m_read_which_entities);

3
third_party/osmium/io/detail/pbf_output_format.hpp vendored
View File

@ -527,9 +527,6 @@ namespace osmium {
std::promise<std::string> promise; std::promise<std::string> promise;
m_output_queue.push(promise.get_future()); m_output_queue.push(promise.get_future());
promise.set_value(serialize_blob("OSMData", pbf_primitive_block, m_use_compression)); promise.set_value(serialize_blob("OSMData", pbf_primitive_block, m_use_compression));
while (m_output_queue.size() > 10) {
std::this_thread::sleep_for(std::chrono::milliseconds(100)); // XXX
}
// clear the PrimitiveBlock struct // clear the PrimitiveBlock struct
pbf_primitive_block.Clear(); pbf_primitive_block.Clear();

449
third_party/osmium/io/detail/pbf_parser.hpp vendored Normal file
View File

@ -0,0 +1,449 @@
#ifndef OSMIUM_IO_DETAIL_PBF_PRIMITIVE_BLOCK_PARSER_HPP
#define OSMIUM_IO_DETAIL_PBF_PRIMITIVE_BLOCK_PARSER_HPP
/*
This file is part of Osmium (http://osmcode.org/libosmium).
Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README).
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:
The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <algorithm>
#include <osmpbf/osmpbf.h>
#include <osmium/builder/osm_object_builder.hpp>
#include <osmium/io/detail/pbf.hpp> // IWYU pragma: export
#include <osmium/io/detail/zlib.hpp>
#include <osmium/io/header.hpp>
#include <osmium/osm/location.hpp>
#include <osmium/osm/node.hpp>
#include <osmium/osm/types.hpp>
#include <osmium/memory/buffer.hpp>
#include <osmium/osm/entity_bits.hpp>
#include <osmium/util/cast.hpp>
namespace osmium {
namespace io {
namespace detail {
class PBFPrimitiveBlockParser {
static constexpr size_t initial_buffer_size = 2 * 1024 * 1024;
const std::string& m_data;
const OSMPBF::StringTable* m_stringtable;
int64_t m_lon_offset;
int64_t m_lat_offset;
int64_t m_date_factor;
int32_t m_granularity;
osmium::osm_entity_bits::type m_read_types;
osmium::memory::Buffer m_buffer;
PBFPrimitiveBlockParser(const PBFPrimitiveBlockParser&) = delete;
PBFPrimitiveBlockParser(PBFPrimitiveBlockParser&&) = delete;
PBFPrimitiveBlockParser& operator=(const PBFPrimitiveBlockParser&) = delete;
PBFPrimitiveBlockParser& operator=(PBFPrimitiveBlockParser&&) = delete;
public:
explicit PBFPrimitiveBlockParser(const std::string& data, osmium::osm_entity_bits::type read_types) :
m_data(data),
m_stringtable(nullptr),
m_lon_offset(0),
m_lat_offset(0),
m_date_factor(1000),
m_granularity(100),
m_read_types(read_types),
m_buffer(initial_buffer_size) {
}
~PBFPrimitiveBlockParser() = default;
osmium::memory::Buffer operator()() {
OSMPBF::PrimitiveBlock pbf_primitive_block;
if (!pbf_primitive_block.ParseFromString(m_data)) {
throw osmium::pbf_error("failed to parse PrimitiveBlock");
}
m_stringtable = &pbf_primitive_block.stringtable();
m_lon_offset = pbf_primitive_block.lon_offset();
m_lat_offset = pbf_primitive_block.lat_offset();
m_date_factor = pbf_primitive_block.date_granularity() / 1000;
m_granularity = pbf_primitive_block.granularity();
for (int i=0; i < pbf_primitive_block.primitivegroup_size(); ++i) {
const OSMPBF::PrimitiveGroup& group = pbf_primitive_block.primitivegroup(i);
if (group.has_dense()) {
if (m_read_types & osmium::osm_entity_bits::node) parse_dense_node_group(group);
} else if (group.ways_size() != 0) {
if (m_read_types & osmium::osm_entity_bits::way) parse_way_group(group);
} else if (group.relations_size() != 0) {
if (m_read_types & osmium::osm_entity_bits::relation) parse_relation_group(group);
} else if (group.nodes_size() != 0) {
if (m_read_types & osmium::osm_entity_bits::node) parse_node_group(group);
} else {
throw osmium::pbf_error("group of unknown type");
}
}
return std::move(m_buffer);
}
private:
template <class TBuilder, class TPBFObject>
void parse_attributes(TBuilder& builder, const TPBFObject& pbf_object) {
auto& object = builder.object();
object.set_id(pbf_object.id());
if (pbf_object.has_info()) {
object.set_version(static_cast_with_assert<object_version_type>(pbf_object.info().version()))
.set_changeset(static_cast_with_assert<changeset_id_type>(pbf_object.info().changeset()))
.set_timestamp(pbf_object.info().timestamp() * m_date_factor)
.set_uid_from_signed(pbf_object.info().uid());
if (pbf_object.info().has_visible()) {
object.set_visible(pbf_object.info().visible());
}
builder.add_user(m_stringtable->s(static_cast_with_assert<int>(pbf_object.info().user_sid())));
} else {
builder.add_user("", 1);
}
}
void parse_node_group(const OSMPBF::PrimitiveGroup& group) {
for (int i=0; i < group.nodes_size(); ++i) {
osmium::builder::NodeBuilder builder(m_buffer);
const OSMPBF::Node& pbf_node = group.nodes(i);
parse_attributes(builder, pbf_node);
if (builder.object().visible()) {
builder.object().set_location(osmium::Location(
(pbf_node.lon() * m_granularity + m_lon_offset) / (OSMPBF::lonlat_resolution / osmium::Location::coordinate_precision),
(pbf_node.lat() * m_granularity + m_lat_offset) / (OSMPBF::lonlat_resolution / osmium::Location::coordinate_precision)));
}
if (pbf_node.keys_size() > 0) {
osmium::builder::TagListBuilder tl_builder(m_buffer, &builder);
for (int tag=0; tag < pbf_node.keys_size(); ++tag) {
tl_builder.add_tag(m_stringtable->s(static_cast<int>(pbf_node.keys(tag))),
m_stringtable->s(static_cast<int>(pbf_node.vals(tag))));
}
}
m_buffer.commit();
}
}
void parse_way_group(const OSMPBF::PrimitiveGroup& group) {
for (int i=0; i < group.ways_size(); ++i) {
osmium::builder::WayBuilder builder(m_buffer);
const OSMPBF::Way& pbf_way = group.ways(i);
parse_attributes(builder, pbf_way);
if (pbf_way.refs_size() > 0) {
osmium::builder::WayNodeListBuilder wnl_builder(m_buffer, &builder);
int64_t ref = 0;
for (int n=0; n < pbf_way.refs_size(); ++n) {
ref += pbf_way.refs(n);
wnl_builder.add_node_ref(ref);
}
}
if (pbf_way.keys_size() > 0) {
osmium::builder::TagListBuilder tl_builder(m_buffer, &builder);
for (int tag=0; tag < pbf_way.keys_size(); ++tag) {
tl_builder.add_tag(m_stringtable->s(static_cast<int>(pbf_way.keys(tag))),
m_stringtable->s(static_cast<int>(pbf_way.vals(tag))));
}
}
m_buffer.commit();
}
}
void parse_relation_group(const OSMPBF::PrimitiveGroup& group) {
for (int i=0; i < group.relations_size(); ++i) {
osmium::builder::RelationBuilder builder(m_buffer);
const OSMPBF::Relation& pbf_relation = group.relations(i);
parse_attributes(builder, pbf_relation);
if (pbf_relation.types_size() > 0) {
osmium::builder::RelationMemberListBuilder rml_builder(m_buffer, &builder);
int64_t ref = 0;
for (int n=0; n < pbf_relation.types_size(); ++n) {
ref += pbf_relation.memids(n);
rml_builder.add_member(osmpbf_membertype_to_item_type(pbf_relation.types(n)), ref, m_stringtable->s(pbf_relation.roles_sid(n)));
}
}
if (pbf_relation.keys_size() > 0) {
osmium::builder::TagListBuilder tl_builder(m_buffer, &builder);
for (int tag=0; tag < pbf_relation.keys_size(); ++tag) {
tl_builder.add_tag(m_stringtable->s(static_cast<int>(pbf_relation.keys(tag))),
m_stringtable->s(static_cast<int>(pbf_relation.vals(tag))));
}
}
m_buffer.commit();
}
}
int add_tags(const OSMPBF::DenseNodes& dense, int n, osmium::builder::NodeBuilder* builder) {
if (n >= dense.keys_vals_size()) {
return n;
}
if (dense.keys_vals(n) == 0) {
return n+1;
}
osmium::builder::TagListBuilder tl_builder(m_buffer, builder);
while (n < dense.keys_vals_size()) {
int tag_key_pos = dense.keys_vals(n++);
if (tag_key_pos == 0) {
break;
}
tl_builder.add_tag(m_stringtable->s(tag_key_pos),
m_stringtable->s(dense.keys_vals(n)));
++n;
}
return n;
}
void parse_dense_node_group(const OSMPBF::PrimitiveGroup& group) {
int64_t last_dense_id = 0;
int64_t last_dense_latitude = 0;
int64_t last_dense_longitude = 0;
int64_t last_dense_uid = 0;
int64_t last_dense_user_sid = 0;
int64_t last_dense_changeset = 0;
int64_t last_dense_timestamp = 0;
int last_dense_tag = 0;
const OSMPBF::DenseNodes& dense = group.dense();
for (int i=0; i < dense.id_size(); ++i) {
bool visible = true;
last_dense_id += dense.id(i);
last_dense_latitude += dense.lat(i);
last_dense_longitude += dense.lon(i);
if (dense.has_denseinfo()) {
last_dense_changeset += dense.denseinfo().changeset(i);
last_dense_timestamp += dense.denseinfo().timestamp(i);
last_dense_uid += dense.denseinfo().uid(i);
last_dense_user_sid += dense.denseinfo().user_sid(i);
if (dense.denseinfo().visible_size() > 0) {
visible = dense.denseinfo().visible(i);
}
assert(last_dense_changeset >= 0);
assert(last_dense_timestamp >= 0);
assert(last_dense_uid >= -1);
assert(last_dense_user_sid >= 0);
}
osmium::builder::NodeBuilder builder(m_buffer);
osmium::Node& node = builder.object();
node.set_id(last_dense_id);
if (dense.has_denseinfo()) {
auto v = dense.denseinfo().version(i);
assert(v > 0);
node.set_version(static_cast<osmium::object_version_type>(v));
node.set_changeset(static_cast<osmium::changeset_id_type>(last_dense_changeset));
node.set_timestamp(last_dense_timestamp * m_date_factor);
node.set_uid_from_signed(static_cast<osmium::signed_user_id_type>(last_dense_uid));
node.set_visible(visible);
builder.add_user(m_stringtable->s(static_cast<int>(last_dense_user_sid)));
} else {
builder.add_user("", 1);
}
if (visible) {
builder.object().set_location(osmium::Location(
(last_dense_longitude * m_granularity + m_lon_offset) / (OSMPBF::lonlat_resolution / osmium::Location::coordinate_precision),
(last_dense_latitude * m_granularity + m_lat_offset) / (OSMPBF::lonlat_resolution / osmium::Location::coordinate_precision)));
}
last_dense_tag = add_tags(dense, last_dense_tag, &builder);
m_buffer.commit();
}
}
}; // class PBFPrimitiveBlockParser
/**
* PBF blobs can optionally be packed with the zlib algorithm.
* This function returns the raw data (if it was unpacked) or
* the unpacked data (if it was packed).
*
* @param input_data Reference to input data.
* @returns Unpacked data
* @throws osmium::pbf_error If there was a problem parsing the PBF
*/
inline std::unique_ptr<const std::string> unpack_blob(const std::string& input_data) {
OSMPBF::Blob pbf_blob;
if (!pbf_blob.ParseFromString(input_data)) {
throw osmium::pbf_error("failed to parse blob");
}
if (pbf_blob.has_raw()) {
return std::unique_ptr<std::string>(pbf_blob.release_raw());
} else if (pbf_blob.has_zlib_data()) {
auto raw_size = pbf_blob.raw_size();
assert(raw_size >= 0);
assert(raw_size <= OSMPBF::max_uncompressed_blob_size);
return osmium::io::detail::zlib_uncompress(pbf_blob.zlib_data(), static_cast<unsigned long>(raw_size));
} else if (pbf_blob.has_lzma_data()) {
throw osmium::pbf_error("lzma blobs not implemented");
} else {
throw osmium::pbf_error("blob contains no data");
}
}
/**
* Parse blob as a HeaderBlock.
*
* @param input_buffer Blob data
* @returns Header object
* @throws osmium::pbf_error If there was a parsing error
*/
inline osmium::io::Header parse_header_blob(const std::string& input_buffer) {
const std::unique_ptr<const std::string> data = unpack_blob(input_buffer);
OSMPBF::HeaderBlock pbf_header_block;
if (!pbf_header_block.ParseFromString(*data)) {
throw osmium::pbf_error("failed to parse HeaderBlock");
}
osmium::io::Header header;
for (int i=0; i < pbf_header_block.required_features_size(); ++i) {
const std::string& feature = pbf_header_block.required_features(i);
if (feature == "OsmSchema-V0.6") continue;
if (feature == "DenseNodes") {
header.set("pbf_dense_nodes", true);
continue;
}
if (feature == "HistoricalInformation") {
header.set_has_multiple_object_versions(true);
continue;
}
throw osmium::pbf_error(std::string("required feature not supported: ") + feature);
}
for (int i=0; i < pbf_header_block.optional_features_size(); ++i) {
const std::string& feature = pbf_header_block.optional_features(i);
header.set("pbf_optional_feature_" + std::to_string(i), feature);
}
if (pbf_header_block.has_writingprogram()) {
header.set("generator", pbf_header_block.writingprogram());
}
if (pbf_header_block.has_bbox()) {
const OSMPBF::HeaderBBox& pbf_bbox = pbf_header_block.bbox();
const int64_t resolution_convert = OSMPBF::lonlat_resolution / osmium::Location::coordinate_precision;
osmium::Box box;
box.extend(osmium::Location(pbf_bbox.left() / resolution_convert, pbf_bbox.bottom() / resolution_convert));
box.extend(osmium::Location(pbf_bbox.right() / resolution_convert, pbf_bbox.top() / resolution_convert));
header.add_box(box);
}
if (pbf_header_block.has_osmosis_replication_timestamp()) {
header.set("osmosis_replication_timestamp", osmium::Timestamp(pbf_header_block.osmosis_replication_timestamp()).to_iso());
}
if (pbf_header_block.has_osmosis_replication_sequence_number()) {
header.set("osmosis_replication_sequence_number", std::to_string(pbf_header_block.osmosis_replication_sequence_number()));
}
if (pbf_header_block.has_osmosis_replication_base_url()) {
header.set("osmosis_replication_base_url", pbf_header_block.osmosis_replication_base_url());
}
return header;
}
class DataBlobParser {
std::string m_input_buffer;
osmium::osm_entity_bits::type m_read_types;
public:
DataBlobParser(std::string&& input_buffer, osmium::osm_entity_bits::type read_types) :
m_input_buffer(std::move(input_buffer)),
m_read_types(read_types) {
if (input_buffer.size() > OSMPBF::max_uncompressed_blob_size) {
throw osmium::pbf_error(std::string("invalid blob size: " + std::to_string(input_buffer.size())));
}
}
DataBlobParser(const DataBlobParser& other) :
m_input_buffer(std::move(other.m_input_buffer)),
m_read_types(other.m_read_types) {
}
DataBlobParser& operator=(const DataBlobParser&) = delete;
osmium::memory::Buffer operator()() {
const std::unique_ptr<const std::string> data = unpack_blob(m_input_buffer);
PBFPrimitiveBlockParser parser(*data, m_read_types);
return std::move(parser());
}
}; // class DataBlobParser
} // namespace detail
} // namespace io
} // namespace osmium
#endif // OSMIUM_IO_DETAIL_PBF_PRIMITIVE_BLOCK_PARSER_HPP

2
third_party/osmium/io/detail/read_thread.hpp vendored
View File

@ -41,8 +41,8 @@ DEALINGS IN THE SOFTWARE.
#include <utility> #include <utility>
#include <osmium/io/compression.hpp> #include <osmium/io/compression.hpp>
#include <osmium/thread/name.hpp>
#include <osmium/thread/queue.hpp> #include <osmium/thread/queue.hpp>
#include <osmium/thread/util.hpp>
namespace osmium { namespace osmium {

2
third_party/osmium/io/detail/write_thread.hpp vendored
View File

@ -38,7 +38,7 @@ DEALINGS IN THE SOFTWARE.
#include <osmium/io/compression.hpp> #include <osmium/io/compression.hpp>
#include <osmium/io/detail/output_format.hpp> #include <osmium/io/detail/output_format.hpp>
#include <osmium/thread/name.hpp> #include <osmium/thread/util.hpp>
namespace osmium { namespace osmium {

29
third_party/osmium/io/detail/xml_input_format.hpp vendored
View File

@ -57,6 +57,7 @@ DEALINGS IN THE SOFTWARE.
#include <osmium/builder/builder.hpp> #include <osmium/builder/builder.hpp>
#include <osmium/builder/osm_object_builder.hpp> #include <osmium/builder/osm_object_builder.hpp>
#include <osmium/io/detail/input_format.hpp> #include <osmium/io/detail/input_format.hpp>
#include <osmium/io/error.hpp>
#include <osmium/io/file_format.hpp> #include <osmium/io/file_format.hpp>
#include <osmium/io/header.hpp> #include <osmium/io/header.hpp>
#include <osmium/memory/buffer.hpp> #include <osmium/memory/buffer.hpp>
@ -68,7 +69,7 @@ DEALINGS IN THE SOFTWARE.
#include <osmium/osm/object.hpp> #include <osmium/osm/object.hpp>
#include <osmium/osm/types.hpp> #include <osmium/osm/types.hpp>
#include <osmium/thread/queue.hpp> #include <osmium/thread/queue.hpp>
#include <osmium/thread/checked_task.hpp> #include <osmium/thread/util.hpp>
#include <osmium/util/cast.hpp> #include <osmium/util/cast.hpp>
namespace osmium { namespace osmium {
@ -178,8 +179,6 @@ namespace osmium {
osmium::osm_entity_bits::type m_read_types; osmium::osm_entity_bits::type m_read_types;
size_t m_max_queue_size;
std::atomic<bool>& m_done; std::atomic<bool>& m_done;
/** /**
@ -270,7 +269,6 @@ namespace osmium {
m_queue(queue), m_queue(queue),
m_header_promise(header_promise), m_header_promise(header_promise),
m_read_types(read_types), m_read_types(read_types),
m_max_queue_size(100),
m_done(done) { m_done(done) {
} }
@ -297,15 +295,14 @@ namespace osmium {
m_queue(other.m_queue), m_queue(other.m_queue),
m_header_promise(other.m_header_promise), m_header_promise(other.m_header_promise),
m_read_types(other.m_read_types), m_read_types(other.m_read_types),
m_max_queue_size(100),
m_done(other.m_done) { m_done(other.m_done) {
} }
XMLParser(XMLParser&& other) = default; XMLParser(XMLParser&&) = default;
XMLParser& operator=(const XMLParser&) = delete; XMLParser& operator=(const XMLParser&) = delete;
XMLParser& operator=(XMLParser&& other) = default; XMLParser& operator=(XMLParser&&) = default;
~XMLParser() = default; ~XMLParser() = default;
@ -650,10 +647,6 @@ namespace osmium {
m_queue.push(std::move(m_buffer)); m_queue.push(std::move(m_buffer));
osmium::memory::Buffer buffer(buffer_size); osmium::memory::Buffer buffer(buffer_size);
std::swap(m_buffer, buffer); std::swap(m_buffer, buffer);
while (m_queue.size() > m_max_queue_size) {
std::this_thread::sleep_for(std::chrono::milliseconds(10));
}
} }
} }
@ -661,12 +654,12 @@ namespace osmium {
class XMLInputFormat : public osmium::io::detail::InputFormat { class XMLInputFormat : public osmium::io::detail::InputFormat {
static constexpr size_t m_max_queue_size = 100; static constexpr size_t max_queue_size = 100;
osmium::thread::Queue<osmium::memory::Buffer> m_queue; osmium::thread::Queue<osmium::memory::Buffer> m_queue;
std::atomic<bool> m_done; std::atomic<bool> m_done;
std::promise<osmium::io::Header> m_header_promise; std::promise<osmium::io::Header> m_header_promise;
osmium::thread::CheckedTask<XMLParser> m_parser_task; std::future<bool> m_parser_future;
public: public:
@ -679,10 +672,10 @@ namespace osmium {
*/ */
explicit XMLInputFormat(const osmium::io::File& file, osmium::osm_entity_bits::type read_which_entities, osmium::thread::Queue<std::string>& input_queue) : explicit XMLInputFormat(const osmium::io::File& file, osmium::osm_entity_bits::type read_which_entities, osmium::thread::Queue<std::string>& input_queue) :
osmium::io::detail::InputFormat(file, read_which_entities, input_queue), osmium::io::detail::InputFormat(file, read_which_entities, input_queue),
m_queue(), m_queue(max_queue_size, "xml_parser_results"),
m_done(false), m_done(false),
m_header_promise(), m_header_promise(),
m_parser_task(input_queue, m_queue, m_header_promise, read_which_entities, m_done) { m_parser_future(std::async(std::launch::async, XMLParser(input_queue, m_queue, m_header_promise, read_which_entities, m_done))) {
} }
~XMLInputFormat() { ~XMLInputFormat() {
@ -694,7 +687,7 @@ namespace osmium {
} }
virtual osmium::io::Header header() override final { virtual osmium::io::Header header() override final {
m_parser_task.check_for_exception(); osmium::thread::check_for_exception(m_parser_future);
return m_header_promise.get_future().get(); return m_header_promise.get_future().get();
} }
@ -704,13 +697,13 @@ namespace osmium {
m_queue.wait_and_pop(buffer); m_queue.wait_and_pop(buffer);
} }
m_parser_task.check_for_exception(); osmium::thread::check_for_exception(m_parser_future);
return buffer; return buffer;
} }
void close() { void close() {
m_done = true; m_done = true;
m_parser_task.close(); osmium::thread::wait_until_done(m_parser_future);
} }
}; // class XMLInputFormat }; // class XMLInputFormat

10
third_party/osmium/io/detail/xml_output_format.hpp vendored
View File

@ -233,8 +233,8 @@ namespace osmium {
XMLOutputBlock(const XMLOutputBlock&) = delete; XMLOutputBlock(const XMLOutputBlock&) = delete;
XMLOutputBlock& operator=(const XMLOutputBlock&) = delete; XMLOutputBlock& operator=(const XMLOutputBlock&) = delete;
XMLOutputBlock(XMLOutputBlock&& other) = default; XMLOutputBlock(XMLOutputBlock&&) = default;
XMLOutputBlock& operator=(XMLOutputBlock&& other) = default; XMLOutputBlock& operator=(XMLOutputBlock&&) = default;
std::string operator()() { std::string operator()() {
osmium::apply(m_input_buffer.cbegin(), m_input_buffer.cend(), *this); osmium::apply(m_input_buffer.cbegin(), m_input_buffer.cend(), *this);
@ -405,11 +405,7 @@ namespace osmium {
} }
void write_buffer(osmium::memory::Buffer&& buffer) override final { void write_buffer(osmium::memory::Buffer&& buffer) override final {
osmium::thread::SharedPtrWrapper<XMLOutputBlock> output_block(std::move(buffer), m_write_visible_flag, m_file.is_true("xml_change_format")); m_output_queue.push(osmium::thread::Pool::instance().submit(XMLOutputBlock{std::move(buffer), m_write_visible_flag, m_file.is_true("xml_change_format")}));
m_output_queue.push(osmium::thread::Pool::instance().submit(std::move(output_block)));
while (m_output_queue.size() > 10) {
std::this_thread::sleep_for(std::chrono::milliseconds(100)); // XXX
}
} }
void write_header(const osmium::io::Header& header) override final { void write_header(const osmium::io::Header& header) override final {

7
third_party/osmium/io/detail/zlib.hpp vendored
View File

@ -35,6 +35,7 @@ DEALINGS IN THE SOFTWARE.
#define OSMIUM_LINK_WITH_LIBS_ZLIB -lz #define OSMIUM_LINK_WITH_LIBS_ZLIB -lz
#include <memory>
#include <stdexcept> #include <stdexcept>
#include <string> #include <string>
@ -76,10 +77,10 @@ namespace osmium {
* @param raw_size Size of uncompressed data. * @param raw_size Size of uncompressed data.
* @returns Uncompressed data. * @returns Uncompressed data.
*/ */
inline std::string zlib_uncompress(const std::string& input, unsigned long raw_size) { inline std::unique_ptr<std::string> zlib_uncompress(const std::string& input, unsigned long raw_size) {
std::string output(raw_size, '\0'); auto output = std::unique_ptr<std::string>(new std::string(raw_size, '\0'));
if (::uncompress(reinterpret_cast<unsigned char*>(const_cast<char *>(output.data())), if (::uncompress(reinterpret_cast<unsigned char*>(const_cast<char *>(output->data())),
&raw_size, &raw_size,
reinterpret_cast<const unsigned char*>(input.data()), reinterpret_cast<const unsigned char*>(input.data()),
input.size()) != Z_OK) { input.size()) != Z_OK) {

57
third_party/osmium/io/error.hpp vendored Normal file
View File

@ -0,0 +1,57 @@
#ifndef OSMIUM_IO_ERROR_HPP
#define OSMIUM_IO_ERROR_HPP
/*
This file is part of Osmium (http://osmcode.org/libosmium).
Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README).
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:
The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/
#include <stdexcept>
namespace osmium {
/**
* Exception thrown when some kind of input/output operation failed.
*/
struct io_error : public std::runtime_error {
io_error(const std::string& what) :
std::runtime_error(what) {
}
io_error(const char* what) :
std::runtime_error(what) {
}
}; // struct io_error
} // namespace osmium
#endif // OSMIUM_IO_ERROR_HPP

23
third_party/osmium/io/file.hpp vendored
View File

@ -45,21 +45,6 @@ DEALINGS IN THE SOFTWARE.
namespace osmium { namespace osmium {
/**
* Exception thrown when some kind of input/output operation failed.
*/
struct io_error : public std::runtime_error {
io_error(const std::string& what) :
std::runtime_error(what) {
}
io_error(const char* what) :
std::runtime_error(what) {
}
}; // struct io_error
/** /**
* @brief Everything related to input and output of OSM data. * @brief Everything related to input and output of OSM data.
*/ */
@ -162,11 +147,11 @@ namespace osmium {
} }
} }
File(const File& other) = default; File(const File&) = default;
File& operator=(const File& other) = default; File& operator=(const File&) = default;
File(File&& other) = default; File(File&&) = default;
File& operator=(File&& other) = default; File& operator=(File&&) = default;
~File() = default; ~File() = default;

104
third_party/osmium/io/overwrite.hpp vendored
View File

@ -1,52 +1,52 @@
#ifndef OSMIUM_IO_OVERWRITE_HPP #ifndef OSMIUM_IO_OVERWRITE_HPP
#define OSMIUM_IO_OVERWRITE_HPP #define OSMIUM_IO_OVERWRITE_HPP
/* /*
This file is part of Osmium (http://osmcode.org/libosmium). This file is part of Osmium (http://osmcode.org/libosmium).
Copyright 2014 Jochen Topf <jochen@topf.org> and others (see README). Copyright 2014 Jochen Topf <jochen@topf.org> and others (see README).
Boost Software License - Version 1.0 - August 17th, 2003 Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute, this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following: do so, all subject to the following:
The copyright notices in the Software and this entire statement, including The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer, the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by works are solely in the form of machine-executable object code generated by
a source language processor. a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE. DEALINGS IN THE SOFTWARE.
*/ */
namespace osmium { namespace osmium {
namespace io { namespace io {
/** /**
* Allow overwriting of existing file. * Allow overwriting of existing file.
*/ */
enum class overwrite : bool { enum class overwrite : bool {
no = false, no = false,
allow = true allow = true
}; };
} // namespace io } // namespace io
} // namespace osmium } // namespace osmium
#endif // OSMIUM_IO_OVERWRITE_HPP #endif // OSMIUM_IO_OVERWRITE_HPP

15
third_party/osmium/io/reader.hpp vendored
View File

@ -59,8 +59,7 @@ DEALINGS IN THE SOFTWARE.
#include <osmium/io/header.hpp> #include <osmium/io/header.hpp>
#include <osmium/memory/buffer.hpp> #include <osmium/memory/buffer.hpp>
#include <osmium/osm/entity_bits.hpp> #include <osmium/osm/entity_bits.hpp>
#include <osmium/thread/checked_task.hpp> #include <osmium/thread/util.hpp>
#include <osmium/thread/name.hpp>
#include <osmium/thread/queue.hpp> #include <osmium/thread/queue.hpp>
namespace osmium { namespace osmium {
@ -83,7 +82,7 @@ namespace osmium {
osmium::thread::Queue<std::string> m_input_queue; osmium::thread::Queue<std::string> m_input_queue;
std::unique_ptr<osmium::io::Decompressor> m_decompressor; std::unique_ptr<osmium::io::Decompressor> m_decompressor;
osmium::thread::CheckedTask<detail::ReadThread> m_read_task; std::future<bool> m_read_future;
std::unique_ptr<osmium::io::detail::InputFormat> m_input; std::unique_ptr<osmium::io::detail::InputFormat> m_input;
@ -173,11 +172,11 @@ namespace osmium {
m_read_which_entities(read_which_entities), m_read_which_entities(read_which_entities),
m_input_done(false), m_input_done(false),
m_childpid(0), m_childpid(0),
m_input_queue(), m_input_queue(20, "raw_input"), // XXX
m_decompressor(m_file.buffer() ? m_decompressor(m_file.buffer() ?
osmium::io::CompressionFactory::instance().create_decompressor(file.compression(), m_file.buffer(), m_file.buffer_size()) : osmium::io::CompressionFactory::instance().create_decompressor(file.compression(), m_file.buffer(), m_file.buffer_size()) :
osmium::io::CompressionFactory::instance().create_decompressor(file.compression(), open_input_file_or_url(m_file.filename(), &m_childpid))), osmium::io::CompressionFactory::instance().create_decompressor(file.compression(), open_input_file_or_url(m_file.filename(), &m_childpid))),
m_read_task(m_input_queue, m_decompressor.get(), m_input_done), m_read_future(std::async(std::launch::async, detail::ReadThread(m_input_queue, m_decompressor.get(), m_input_done))),
m_input(osmium::io::detail::InputFormatFactory::instance().create_input(m_file, m_read_which_entities, m_input_queue)) { m_input(osmium::io::detail::InputFormatFactory::instance().create_input(m_file, m_read_which_entities, m_input_queue)) {
} }
@ -228,7 +227,7 @@ namespace osmium {
} }
#endif #endif
m_read_task.close(); osmium::thread::wait_until_done(m_read_future);
} }
/** /**
@ -251,7 +250,7 @@ namespace osmium {
osmium::memory::Buffer read() { osmium::memory::Buffer read() {
// If an exception happened in the input thread, re-throw // If an exception happened in the input thread, re-throw
// it in this (the main) thread. // it in this (the main) thread.
m_read_task.check_for_exception(); osmium::thread::check_for_exception(m_read_future);
if (m_read_which_entities == osmium::osm_entity_bits::nothing || m_input_done) { if (m_read_which_entities == osmium::osm_entity_bits::nothing || m_input_done) {
// If the caller didn't want anything but the header, it will // If the caller didn't want anything but the header, it will
@ -270,7 +269,7 @@ namespace osmium {
* Has the end of file been reached? This is set after the last * Has the end of file been reached? This is set after the last
* data has been read. It is also set by calling close(). * data has been read. It is also set by calling close().
*/ */
bool eof() { bool eof() const {
return m_input_done; return m_input_done;
} }

102
third_party/osmium/io/reader_iterator.hpp vendored
View File

@ -1,51 +1,51 @@
#ifndef OSMIUM_IO_READER_ITERATOR_HPP #ifndef OSMIUM_IO_READER_ITERATOR_HPP
#define OSMIUM_IO_READER_ITERATOR_HPP #define OSMIUM_IO_READER_ITERATOR_HPP
/* /*
This file is part of Osmium (http://osmcode.org/libosmium). This file is part of Osmium (http://osmcode.org/libosmium).
Copyright 2014 Jochen Topf <jochen@topf.org> and others (see README). Copyright 2014 Jochen Topf <jochen@topf.org> and others (see README).
Boost Software License - Version 1.0 - August 17th, 2003 Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute, this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following: do so, all subject to the following:
The copyright notices in the Software and this entire statement, including The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer, the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by works are solely in the form of machine-executable object code generated by
a source language processor. a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE. DEALINGS IN THE SOFTWARE.
*/ */
#include <osmium/io/reader.hpp> #include <osmium/io/reader.hpp>
#include <osmium/io/input_iterator.hpp> #include <osmium/io/input_iterator.hpp>
namespace std { namespace std {
inline osmium::io::InputIterator<osmium::io::Reader> begin(osmium::io::Reader& reader) { inline osmium::io::InputIterator<osmium::io::Reader> begin(osmium::io::Reader& reader) {
return osmium::io::InputIterator<osmium::io::Reader>(reader); return osmium::io::InputIterator<osmium::io::Reader>(reader);
} }
inline osmium::io::InputIterator<osmium::io::Reader> end(osmium::io::Reader&) { inline osmium::io::InputIterator<osmium::io::Reader> end(osmium::io::Reader&) {
return osmium::io::InputIterator<osmium::io::Reader>(); return osmium::io::InputIterator<osmium::io::Reader>();
} }
} // namespace std } // namespace std
#endif // OSMIUM_IO_READER_ITERATOR_HPP #endif // OSMIUM_IO_READER_ITERATOR_HPP

14
third_party/osmium/io/writer.hpp vendored
View File

@ -45,7 +45,7 @@ DEALINGS IN THE SOFTWARE.
#include <osmium/io/header.hpp> #include <osmium/io/header.hpp>
#include <osmium/io/overwrite.hpp> #include <osmium/io/overwrite.hpp>
#include <osmium/memory/buffer.hpp> #include <osmium/memory/buffer.hpp>
#include <osmium/thread/checked_task.hpp> #include <osmium/thread/util.hpp>
namespace osmium { namespace osmium {
@ -61,12 +61,13 @@ namespace osmium {
osmium::io::File m_file; osmium::io::File m_file;
std::unique_ptr<osmium::io::detail::OutputFormat> m_output;
osmium::io::detail::data_queue_type m_output_queue; osmium::io::detail::data_queue_type m_output_queue;
std::unique_ptr<osmium::io::detail::OutputFormat> m_output;
std::unique_ptr<osmium::io::Compressor> m_compressor; std::unique_ptr<osmium::io::Compressor> m_compressor;
osmium::thread::CheckedTask<detail::WriteThread> m_write_task; std::future<bool> m_write_future;
public: public:
@ -87,9 +88,10 @@ namespace osmium {
*/ */
explicit Writer(const osmium::io::File& file, const osmium::io::Header& header = osmium::io::Header(), overwrite allow_overwrite = overwrite::no) : explicit Writer(const osmium::io::File& file, const osmium::io::Header& header = osmium::io::Header(), overwrite allow_overwrite = overwrite::no) :
m_file(file), m_file(file),
m_output_queue(20, "raw_output"), // XXX
m_output(osmium::io::detail::OutputFormatFactory::instance().create_output(m_file, m_output_queue)), m_output(osmium::io::detail::OutputFormatFactory::instance().create_output(m_file, m_output_queue)),
m_compressor(osmium::io::CompressionFactory::instance().create_compressor(file.compression(), osmium::io::detail::open_for_writing(m_file.filename(), allow_overwrite))), m_compressor(osmium::io::CompressionFactory::instance().create_compressor(file.compression(), osmium::io::detail::open_for_writing(m_file.filename(), allow_overwrite))),
m_write_task(m_output_queue, m_compressor.get()) { m_write_future(std::async(std::launch::async, detail::WriteThread(m_output_queue, m_compressor.get()))) {
assert(!m_file.buffer()); assert(!m_file.buffer());
m_output->write_header(header); m_output->write_header(header);
} }
@ -115,7 +117,7 @@ namespace osmium {
* @throws Some form of std::runtime_error when there is a problem. * @throws Some form of std::runtime_error when there is a problem.
*/ */
void operator()(osmium::memory::Buffer&& buffer) { void operator()(osmium::memory::Buffer&& buffer) {
m_write_task.check_for_exception(); osmium::thread::check_for_exception(m_write_future);
if (buffer.committed() > 0) { if (buffer.committed() > 0) {
m_output->write_buffer(std::move(buffer)); m_output->write_buffer(std::move(buffer));
} }
@ -131,7 +133,7 @@ namespace osmium {
*/ */
void close() { void close() {
m_output->close(); m_output->close();
m_write_task.close(); osmium::thread::wait_until_done(m_write_future);
} }
}; // class Writer }; // class Writer

13
third_party/osmium/memory/item.hpp vendored
View File

@ -35,6 +35,7 @@ DEALINGS IN THE SOFTWARE.
#include <cstddef> #include <cstddef>
#include <cstdint> #include <cstdint>
#include <type_traits>
namespace osmium { namespace osmium {
@ -52,11 +53,10 @@ namespace osmium {
// align datastructures to this many bytes // align datastructures to this many bytes
constexpr item_size_type align_bytes = 8; constexpr item_size_type align_bytes = 8;
inline size_t padded_length(size_t length) noexcept { template <typename T>
return (length + align_bytes - 1) & ~(align_bytes - 1); inline T padded_length(T length) noexcept {
} static_assert(std::is_integral<T>::value && std::is_unsigned<T>::value,
"Template parameter must be unsigned integral type");
inline item_size_type padded_length(item_size_type length) noexcept {
return (length + align_bytes - 1) & ~(align_bytes - 1); return (length + align_bytes - 1) & ~(align_bytes - 1);
} }
@ -122,7 +122,8 @@ namespace osmium {
explicit Item(item_size_type size=0, item_type type=item_type()) noexcept : explicit Item(item_size_type size=0, item_type type=item_type()) noexcept :
m_size(size), m_size(size),
m_type(type), m_type(type),
m_removed(false) { m_removed(false),
m_padding(0) {
} }
Item(const Item&) = delete; Item(const Item&) = delete;

96
third_party/osmium/osm.hpp vendored
View File

@ -1,48 +1,48 @@
#ifndef OSMIUM_OSM_HPP #ifndef OSMIUM_OSM_HPP
#define OSMIUM_OSM_HPP #define OSMIUM_OSM_HPP
/* /*
This file is part of Osmium (http://osmcode.org/libosmium). This file is part of Osmium (http://osmcode.org/libosmium).
Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README). Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README).
Boost Software License - Version 1.0 - August 17th, 2003 Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute, this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following: do so, all subject to the following:
The copyright notices in the Software and this entire statement, including The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer, the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by works are solely in the form of machine-executable object code generated by
a source language processor. a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE. DEALINGS IN THE SOFTWARE.
*/ */
#include <osmium/osm/node.hpp> // IWYU pragma: export #include <osmium/osm/node.hpp> // IWYU pragma: export
#include <osmium/osm/way.hpp> // IWYU pragma: export #include <osmium/osm/way.hpp> // IWYU pragma: export
#include <osmium/osm/relation.hpp> // IWYU pragma: export #include <osmium/osm/relation.hpp> // IWYU pragma: export
#include <osmium/osm/area.hpp> // IWYU pragma: export #include <osmium/osm/area.hpp> // IWYU pragma: export
#include <osmium/osm/changeset.hpp> // IWYU pragma: export #include <osmium/osm/changeset.hpp> // IWYU pragma: export
/** /**
* @brief Namespace for everything in the Osmium library. * @brief Namespace for everything in the Osmium library.
*/ */
namespace osmium { namespace osmium {
} // namespace osmium } // namespace osmium
#endif // OSMIUM_OSM_HPP #endif // OSMIUM_OSM_HPP

16
third_party/osmium/osm/diff_object.hpp vendored
View File

@ -66,11 +66,11 @@ namespace osmium {
m_next(&next) { m_next(&next) {
} }
DiffObject(const DiffObject& other) = default; DiffObject(const DiffObject&) = default;
DiffObject& operator=(const DiffObject& other) = default; DiffObject& operator=(const DiffObject&) = default;
DiffObject(DiffObject&& other) = default; DiffObject(DiffObject&&) = default;
DiffObject& operator=(DiffObject&& other) = default; DiffObject& operator=(DiffObject&&) = default;
const osmium::OSMObject& prev() const noexcept { const osmium::OSMObject& prev() const noexcept {
return *m_prev; return *m_prev;
@ -127,11 +127,11 @@ namespace osmium {
DiffObject(prev, curr, next) { DiffObject(prev, curr, next) {
} }
DiffObjectDerived(const DiffObjectDerived& other) = default; DiffObjectDerived(const DiffObjectDerived&) = default;
DiffObjectDerived& operator=(const DiffObjectDerived& other) = default; DiffObjectDerived& operator=(const DiffObjectDerived&) = default;
DiffObjectDerived(DiffObjectDerived&& other) = default; DiffObjectDerived(DiffObjectDerived&&) = default;
DiffObjectDerived& operator=(DiffObjectDerived&& other) = default; DiffObjectDerived& operator=(DiffObjectDerived&&) = default;
const T& prev() const noexcept { const T& prev() const noexcept {
return *static_cast<const T*>(m_prev); return *static_cast<const T*>(m_prev);

6
third_party/osmium/osm/entity_bits.hpp vendored
View File

@ -61,7 +61,9 @@ namespace osmium {
node = 0x01, node = 0x01,
way = 0x02, way = 0x02,
relation = 0x04, relation = 0x04,
nwr = 0x07, ///< node, way, or relation object
area = 0x08, area = 0x08,
nwra = 0x0f, ///< node, way, relation, or area object
object = 0x0f, ///< node, way, relation, or area object object = 0x0f, ///< node, way, relation, or area object
changeset = 0x10, changeset = 0x10,
all = 0x1f ///< object or changeset all = 0x1f ///< object or changeset
@ -81,6 +83,10 @@ namespace osmium {
return static_cast<type>(static_cast<int>(lhs) & static_cast<int> (rhs)); return static_cast<type>(static_cast<int>(lhs) & static_cast<int> (rhs));
} }
inline type operator~(const type value) noexcept {
return static_cast<type>(~static_cast<int>(value));
}
inline type operator&=(type& lhs, const type rhs) noexcept { inline type operator&=(type& lhs, const type rhs) noexcept {
lhs = lhs & rhs; lhs = lhs & rhs;
return lhs; return lhs;

4
third_party/osmium/relations/collector.hpp vendored
View File

@ -115,6 +115,8 @@ namespace osmium {
}; // class HandlerPass1 }; // class HandlerPass1
public:
/** /**
* This is the handler class for the second pass of the Collector. * This is the handler class for the second pass of the Collector.
*/ */
@ -244,7 +246,7 @@ namespace osmium {
int m_count_complete = 0; int m_count_complete = 0;
typedef std::function<void(const osmium::memory::Buffer&)> callback_func_type; typedef std::function<void(osmium::memory::Buffer&&)> callback_func_type;
callback_func_type m_callback; callback_func_type m_callback;
static constexpr size_t initial_buffer_size = 1024 * 1024; static constexpr size_t initial_buffer_size = 1024 * 1024;

134
third_party/osmium/tags/taglist.hpp vendored
View File

@ -1,67 +1,67 @@
#ifndef OSMIUM_TAGS_TAGLIST_HPP #ifndef OSMIUM_TAGS_TAGLIST_HPP
#define OSMIUM_TAGS_TAGLIST_HPP #define OSMIUM_TAGS_TAGLIST_HPP
/* /*
This file is part of Osmium (http://osmcode.org/libosmium). This file is part of Osmium (http://osmcode.org/libosmium).
Copyright 2014 Jochen Topf <jochen@topf.org> and others (see README). Copyright 2014 Jochen Topf <jochen@topf.org> and others (see README).
Boost Software License - Version 1.0 - August 17th, 2003 Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute, this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following: do so, all subject to the following:
The copyright notices in the Software and this entire statement, including The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer, the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by works are solely in the form of machine-executable object code generated by
a source language processor. a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE. DEALINGS IN THE SOFTWARE.
*/ */
#include <algorithm> #include <algorithm>
#include <utility> #include <utility>
#include <osmium/osm/tag.hpp> #include <osmium/osm/tag.hpp>
namespace osmium { namespace osmium {
/** /**
* @brief Code related to working with OSM tags * @brief Code related to working with OSM tags
*/ */
namespace tags { namespace tags {
template <class TFilter> template <class TFilter>
inline bool match_any_of(const osmium::TagList& tag_list, TFilter&& filter) { inline bool match_any_of(const osmium::TagList& tag_list, TFilter&& filter) {
return std::any_of(tag_list.begin(), tag_list.end(), std::forward<TFilter>(filter)); return std::any_of(tag_list.begin(), tag_list.end(), std::forward<TFilter>(filter));
} }
template <class TFilter> template <class TFilter>
inline bool match_all_of(const osmium::TagList& tag_list, TFilter&& filter) { inline bool match_all_of(const osmium::TagList& tag_list, TFilter&& filter) {
return std::all_of(tag_list.begin(), tag_list.end(), std::forward<TFilter>(filter)); return std::all_of(tag_list.begin(), tag_list.end(), std::forward<TFilter>(filter));
} }
template <class TFilter> template <class TFilter>
inline bool match_none_of(const osmium::TagList& tag_list, TFilter&& filter) { inline bool match_none_of(const osmium::TagList& tag_list, TFilter&& filter) {
return std::none_of(tag_list.begin(), tag_list.end(), std::forward<TFilter>(filter)); return std::none_of(tag_list.begin(), tag_list.end(), std::forward<TFilter>(filter));
} }
} // namespace tags } // namespace tags
} // namespace osmium } // namespace osmium
#endif // OSMIUM_TAGS_TAGLIST_HPP #endif // OSMIUM_TAGS_TAGLIST_HPP

12
third_party/osmium/thread/function_wrapper.hpp vendored
View File

@ -40,12 +40,18 @@ namespace osmium {
namespace thread { namespace thread {
/**
* This function wrapper can collect move-only functions unlike
* std::function which needs copyable functions.
* Taken from the book "C++ Concurrency in Action".
*/
class function_wrapper { class function_wrapper {
struct impl_base { struct impl_base {
virtual ~impl_base() = default;
virtual void call() = 0; virtual void call() = 0;
virtual ~impl_base() {
}
}; // struct impl_base }; // struct impl_base
std::unique_ptr<impl_base> impl; std::unique_ptr<impl_base> impl;
@ -58,7 +64,7 @@ namespace osmium {
m_functor(std::move(functor)) { m_functor(std::move(functor)) {
} }
void call() { void call() override {
m_functor(); m_functor();
} }
}; // struct impl_type }; // struct impl_type

48
third_party/osmium/thread/pool.hpp vendored
View File

@ -42,9 +42,10 @@ DEALINGS IN THE SOFTWARE.
#include <type_traits> #include <type_traits>
#include <vector> #include <vector>
#include <osmium/thread/queue.hpp>
#include <osmium/thread/name.hpp>
#include <osmium/thread/function_wrapper.hpp> #include <osmium/thread/function_wrapper.hpp>
#include <osmium/thread/queue.hpp>
#include <osmium/thread/util.hpp>
#include <osmium/util/config.hpp>
namespace osmium { namespace osmium {
@ -58,7 +59,10 @@ namespace osmium {
*/ */
class Pool { class Pool {
// This class makes sure pool threads are joined when the pool is destructed /**
* This class makes sure all pool threads will be joined when
* the pool is destructed.
*/
class thread_joiner { class thread_joiner {
std::vector<std::thread>& m_threads; std::vector<std::thread>& m_threads;
@ -108,20 +112,15 @@ namespace osmium {
* *
* In all cases the minimum number of threads in the pool is 1. * In all cases the minimum number of threads in the pool is 1.
*/ */
explicit Pool(int num_threads) : explicit Pool(int num_threads, size_t max_queue_size) :
m_done(false), m_done(false),
m_work_queue(), m_work_queue(max_queue_size, "work"),
m_threads(), m_threads(),
m_joiner(m_threads), m_joiner(m_threads),
m_num_threads(num_threads) { m_num_threads(num_threads) {
if (m_num_threads == 0) { if (m_num_threads == 0) {
const char* env_threads = getenv("OSMIUM_POOL_THREADS"); m_num_threads = osmium::config::get_pool_threads();
if (env_threads) {
m_num_threads = std::atoi(env_threads);
} else {
m_num_threads = -2;
}
} }
if (m_num_threads <= 0) { if (m_num_threads <= 0) {
@ -141,9 +140,10 @@ namespace osmium {
public: public:
static constexpr int default_num_threads = 0; static constexpr int default_num_threads = 0;
static constexpr size_t max_work_queue_size = 10;
static Pool& instance() { static Pool& instance() {
static Pool pool(default_num_threads); static Pool pool(default_num_threads, max_work_queue_size);
return pool; return pool;
} }
@ -173,30 +173,6 @@ namespace osmium {
}; // class Pool }; // class Pool
/**
* Wrapper for classes that can't be copied but need to be copyable for
* putting them in the pool.
*/
template <class TWrapped>
class SharedPtrWrapper {
std::shared_ptr<TWrapped> m_task;
public:
typedef typename std::result_of<TWrapped()>::type result_type;
template <typename... TArgs>
SharedPtrWrapper(TArgs&&... args) :
m_task(std::make_shared<TWrapped>(std::forward<TArgs>(args)...)) {
}
result_type operator()() {
return m_task->operator()();
}
}; // class SharedPtrWrapper
} // namespace thread } // namespace thread
} // namespace osmium } // namespace osmium

76
third_party/osmium/thread/queue.hpp vendored
View File

@ -33,52 +33,102 @@ DEALINGS IN THE SOFTWARE.
*/ */
#include <atomic>
#include <chrono> #include <chrono>
#include <condition_variable> #include <condition_variable>
#include <cstddef> #include <cstddef>
#include <mutex> #include <mutex>
#include <queue> #include <queue>
#include <thread>
#include <utility> #include <utility>
namespace osmium { namespace osmium {
namespace thread { namespace thread {
constexpr std::chrono::milliseconds full_queue_sleep_duration { 10 }; // XXX
/** /**
* A thread-safe queue. * A thread-safe queue.
*/ */
template <typename T> template <typename T>
class Queue { class Queue {
/// Maximum size of this queue. If the queue is full pushing to
/// the queue will block.
const size_t m_max_size;
/// Name of this queue (for debugging only).
const std::string m_name;
mutable std::mutex m_mutex; mutable std::mutex m_mutex;
std::queue<T> m_queue; std::queue<T> m_queue;
/// Used to signal readers when data is available in the queue.
std::condition_variable m_data_available; std::condition_variable m_data_available;
#ifdef OSMIUM_DEBUG_QUEUE_SIZE
/// The largest size the queue has been so far.
size_t m_largest_size;
/// The number of times the queue was full and a thread pushing
/// to the queue was blocked.
std::atomic<int> m_full_counter;
#endif
public: public:
Queue() : /**
* Construct a multithreaded queue.
*
* @param max_size Maximum number of elements in the queue. Set to
* 0 for an unlimited size.
* @param name Optional name for this queue. (Used for debugging.)
*/
Queue(size_t max_size = 0, const std::string& name = "") :
m_max_size(max_size),
m_name(name),
m_mutex(), m_mutex(),
m_queue(), m_queue(),
m_data_available() { m_data_available()
#ifdef OSMIUM_DEBUG_QUEUE_SIZE
,
m_largest_size(0),
m_full_counter(0)
#endif
{
} }
~Queue() {
#ifdef OSMIUM_DEBUG_QUEUE_SIZE
std::cerr << "queue '" << m_name << "' with max_size=" << m_max_size << " had largest size " << m_largest_size << " and was full " << m_full_counter << " times\n";
#endif
}
/**
* Push an element onto the queue. If the queue has a max size, this
* call will block if the queue is full.
*/
void push(T value) { void push(T value) {
if (m_max_size) {
while (size() >= m_max_size) {
std::this_thread::sleep_for(full_queue_sleep_duration);
#ifdef OSMIUM_DEBUG_QUEUE_SIZE
++m_full_counter;
#endif
}
}
std::lock_guard<std::mutex> lock(m_mutex); std::lock_guard<std::mutex> lock(m_mutex);
m_queue.push(std::move(value)); m_queue.push(std::move(value));
#ifdef OSMIUM_DEBUG_QUEUE_SIZE
if (m_largest_size < m_queue.size()) {
m_largest_size = m_queue.size();
}
#endif
m_data_available.notify_one(); m_data_available.notify_one();
} }
size_t push_and_get_size(T&& value) {
std::lock_guard<std::mutex> lock(m_mutex);
m_queue.push(std::forward<T>(value));
m_data_available.notify_one();
return m_queue.size();
}
void push(T value, int) {
push(value);
}
void wait_and_pop(T& value) { void wait_and_pop(T& value) {
std::unique_lock<std::mutex> lock(m_mutex); std::unique_lock<std::mutex> lock(m_mutex);
m_data_available.wait(lock, [this] { m_data_available.wait(lock, [this] {

87
third_party/osmium/thread/util.hpp vendored Normal file
View File

@ -0,0 +1,87 @@
#ifndef OSMIUM_THREAD_UTIL_HPP
#define OSMIUM_THREAD_UTIL_HPP
/*
This file is part of Osmium (http://osmcode.org/libosmium).
Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README).
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:
The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/
#include <chrono>
#include <future>
#ifdef __linux__
# include <sys/prctl.h>
#endif
namespace osmium {
namespace thread {
/**
* Check if the future resulted in an exception. This will re-throw
* the exception stored in the future if there was one. Otherwise it
* will just return.
*/
template <class T>
inline void check_for_exception(std::future<T>& future) {
if (future.valid() && future.wait_for(std::chrono::seconds(0)) == std::future_status::ready) {
future.get();
}
}
/**
* Wait until the given future becomes ready. Will block if the future
* is not ready. Can be called more than once unless future.get().
*/
template <class T>
inline void wait_until_done(std::future<T>& future) {
if (future.valid()) {
future.get();
}
}
/**
* Set name of current thread for debugging. This only works on Linux.
*/
#ifdef __linux__
inline void set_thread_name(const char* name) {
prctl(PR_SET_NAME, name, 0, 0, 0);
}
#else
inline void set_thread_name(const char*) {
// intentionally left blank
}
#endif
} // namespace thread
} // namespace osmium
#endif // OSMIUM_THREAD_UTIL_HPP

4
third_party/osmium/util/cast.hpp vendored
View File

@ -44,7 +44,7 @@ namespace osmium {
static_assert(sizeof(T) < sizeof(F), "unnecessary static_cast_with_assert when casting into type of equal or larger size"); static_assert(sizeof(T) < sizeof(F), "unnecessary static_cast_with_assert when casting into type of equal or larger size");
assert(value >= std::numeric_limits<T>::min() && value <= std::numeric_limits<T>::max()); assert(value >= std::numeric_limits<T>::min() && value <= std::numeric_limits<T>::max());
return static_cast<T>(value); return static_cast<T>(value);
} }
template <typename T, typename F, typename std::enable_if<std::is_integral<T>::value && std::is_integral<F>::value && std::is_unsigned<T>::value && std::is_signed<F>::value, int>::type = 0> template <typename T, typename F, typename std::enable_if<std::is_integral<T>::value && std::is_integral<F>::value && std::is_unsigned<T>::value && std::is_signed<F>::value, int>::type = 0>
inline T static_cast_with_assert(const F value) { inline T static_cast_with_assert(const F value) {
@ -65,7 +65,7 @@ namespace osmium {
static_assert(sizeof(T) <= sizeof(F), "unnecessary static_cast_with_assert when casting into type of larger size"); static_assert(sizeof(T) <= sizeof(F), "unnecessary static_cast_with_assert when casting into type of larger size");
assert(value <= std::numeric_limits<T>::max()); assert(value <= std::numeric_limits<T>::max());
return static_cast<T>(value); return static_cast<T>(value);
} }
} // namespace osmium } // namespace osmium

68
third_party/osmium/util/config.hpp vendored Normal file
View File

@ -0,0 +1,68 @@
#ifndef OSMIUM_UTIL_CONFIG_HPP
#define OSMIUM_UTIL_CONFIG_HPP
/*
This file is part of Osmium (http://osmcode.org/libosmium).
Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README).
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:
The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/
#include <cstdlib>
#include <cstring>
namespace osmium {
namespace config {
inline int get_pool_threads() {
const char* env = getenv("OSMIUM_POOL_THREADS");
if (env) {
return std::atoi(env);
}
return -2;
}
inline bool use_pool_threads_for_pbf_parsing() {
const char* env = getenv("OSMIUM_USE_POOL_THREADS_FOR_PBF_PARSING");
if (env) {
if (!strcasecmp(env, "off") ||
!strcasecmp(env, "false") ||
!strcasecmp(env, "no") ||
!strcasecmp(env, "0")) {
return false;
}
}
return true;
}
} // namespace config
} // namespace osmium
#endif // OSMIUM_UTIL_CONFIG_HPP

510
third_party/osmium/visitor.hpp vendored
View File

@ -1,255 +1,255 @@
#ifndef OSMIUM_VISITOR_HPP #ifndef OSMIUM_VISITOR_HPP
#define OSMIUM_VISITOR_HPP #define OSMIUM_VISITOR_HPP
/* /*
This file is part of Osmium (http://osmcode.org/libosmium). This file is part of Osmium (http://osmcode.org/libosmium).
Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README). Copyright 2013,2014 Jochen Topf <jochen@topf.org> and others (see README).
Boost Software License - Version 1.0 - August 17th, 2003 Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute, this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following: do so, all subject to the following:
The copyright notices in the Software and this entire statement, including The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer, the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by works are solely in the form of machine-executable object code generated by
a source language processor. a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE. DEALINGS IN THE SOFTWARE.
*/ */
#include <type_traits> #include <type_traits>
#include <osmium/io/reader_iterator.hpp> // IWYU pragma: keep #include <osmium/io/reader_iterator.hpp> // IWYU pragma: keep
#include <osmium/memory/buffer.hpp> #include <osmium/memory/buffer.hpp>
#include <osmium/osm.hpp> #include <osmium/osm.hpp>
#include <osmium/osm/entity.hpp> #include <osmium/osm/entity.hpp>
#include <osmium/osm/item_type.hpp> #include <osmium/osm/item_type.hpp>
namespace osmium { namespace osmium {
class TagList; class TagList;
class WayNodeList; class WayNodeList;
class RelationMemberList; class RelationMemberList;
class OuterRing; class OuterRing;
class InnerRing; class InnerRing;
namespace memory { namespace memory {
class Item; class Item;
} }
namespace detail { namespace detail {
template <typename T, typename U> template <typename T, typename U>
using ConstIfConst = typename std::conditional<std::is_const<T>::value, typename std::add_const<U>::type, U>::type; using ConstIfConst = typename std::conditional<std::is_const<T>::value, typename std::add_const<U>::type, U>::type;
template <class THandler, class TItem> template <class THandler, class TItem>
inline void apply_item_recurse(TItem& item, THandler& handler) { inline void apply_item_recurse(TItem& item, THandler& handler) {
switch (item.type()) { switch (item.type()) {
case osmium::item_type::undefined: case osmium::item_type::undefined:
break; break;
case osmium::item_type::node: case osmium::item_type::node:
handler.osm_object(static_cast<ConstIfConst<TItem, osmium::OSMObject>&>(item)); handler.osm_object(static_cast<ConstIfConst<TItem, osmium::OSMObject>&>(item));
handler.node(static_cast<ConstIfConst<TItem, osmium::Node>&>(item)); handler.node(static_cast<ConstIfConst<TItem, osmium::Node>&>(item));
break; break;
case osmium::item_type::way: case osmium::item_type::way:
handler.osm_object(static_cast<ConstIfConst<TItem, osmium::OSMObject>&>(item)); handler.osm_object(static_cast<ConstIfConst<TItem, osmium::OSMObject>&>(item));
handler.way(static_cast<ConstIfConst<TItem, osmium::Way>&>(item)); handler.way(static_cast<ConstIfConst<TItem, osmium::Way>&>(item));
break; break;
case osmium::item_type::relation: case osmium::item_type::relation:
handler.osm_object(static_cast<ConstIfConst<TItem, osmium::OSMObject>&>(item)); handler.osm_object(static_cast<ConstIfConst<TItem, osmium::OSMObject>&>(item));
handler.relation(static_cast<ConstIfConst<TItem, osmium::Relation>&>(item)); handler.relation(static_cast<ConstIfConst<TItem, osmium::Relation>&>(item));
break; break;
case osmium::item_type::area: case osmium::item_type::area:
handler.osm_object(static_cast<ConstIfConst<TItem, osmium::OSMObject>&>(item)); handler.osm_object(static_cast<ConstIfConst<TItem, osmium::OSMObject>&>(item));
handler.area(static_cast<ConstIfConst<TItem, osmium::Area>&>(item)); handler.area(static_cast<ConstIfConst<TItem, osmium::Area>&>(item));
break; break;
case osmium::item_type::changeset: case osmium::item_type::changeset:
handler.changeset(static_cast<ConstIfConst<TItem, osmium::Changeset>&>(item)); handler.changeset(static_cast<ConstIfConst<TItem, osmium::Changeset>&>(item));
break; break;
case osmium::item_type::tag_list: case osmium::item_type::tag_list:
handler.tag_list(static_cast<ConstIfConst<TItem, osmium::TagList>&>(item)); handler.tag_list(static_cast<ConstIfConst<TItem, osmium::TagList>&>(item));
break; break;
case osmium::item_type::way_node_list: case osmium::item_type::way_node_list:
handler.way_node_list(static_cast<ConstIfConst<TItem, osmium::WayNodeList>&>(item)); handler.way_node_list(static_cast<ConstIfConst<TItem, osmium::WayNodeList>&>(item));
break; break;
case osmium::item_type::relation_member_list: case osmium::item_type::relation_member_list:
case osmium::item_type::relation_member_list_with_full_members: case osmium::item_type::relation_member_list_with_full_members:
handler.relation_member_list(static_cast<ConstIfConst<TItem, osmium::RelationMemberList>&>(item)); handler.relation_member_list(static_cast<ConstIfConst<TItem, osmium::RelationMemberList>&>(item));
break; break;
case osmium::item_type::outer_ring: case osmium::item_type::outer_ring:
handler.outer_ring(static_cast<ConstIfConst<TItem, osmium::OuterRing>&>(item)); handler.outer_ring(static_cast<ConstIfConst<TItem, osmium::OuterRing>&>(item));
break; break;
case osmium::item_type::inner_ring: case osmium::item_type::inner_ring:
handler.inner_ring(static_cast<ConstIfConst<TItem, osmium::InnerRing>&>(item)); handler.inner_ring(static_cast<ConstIfConst<TItem, osmium::InnerRing>&>(item));
break; break;
} }
} }
template <class THandler> template <class THandler>
inline void apply_item_recurse(const osmium::OSMEntity& item, THandler& handler) { inline void apply_item_recurse(const osmium::OSMEntity& item, THandler& handler) {
switch (item.type()) { switch (item.type()) {
case osmium::item_type::node: case osmium::item_type::node:
handler.osm_object(static_cast<const osmium::OSMObject&>(item)); handler.osm_object(static_cast<const osmium::OSMObject&>(item));
handler.node(static_cast<const osmium::Node&>(item)); handler.node(static_cast<const osmium::Node&>(item));
break; break;
case osmium::item_type::way: case osmium::item_type::way:
handler.osm_object(static_cast<const osmium::OSMObject&>(item)); handler.osm_object(static_cast<const osmium::OSMObject&>(item));
handler.way(static_cast<const osmium::Way&>(item)); handler.way(static_cast<const osmium::Way&>(item));
break; break;
case osmium::item_type::relation: case osmium::item_type::relation:
handler.osm_object(static_cast<const osmium::OSMObject&>(item)); handler.osm_object(static_cast<const osmium::OSMObject&>(item));
handler.relation(static_cast<const osmium::Relation&>(item)); handler.relation(static_cast<const osmium::Relation&>(item));
break; break;
case osmium::item_type::area: case osmium::item_type::area:
handler.osm_object(static_cast<const osmium::OSMObject&>(item)); handler.osm_object(static_cast<const osmium::OSMObject&>(item));
handler.area(static_cast<const osmium::Area&>(item)); handler.area(static_cast<const osmium::Area&>(item));
break; break;
case osmium::item_type::changeset: case osmium::item_type::changeset:
handler.changeset(static_cast<const osmium::Changeset&>(item)); handler.changeset(static_cast<const osmium::Changeset&>(item));
break; break;
default: default:
throw osmium::unknown_type(); throw osmium::unknown_type();
} }
} }
template <class THandler> template <class THandler>
inline void apply_item_recurse(osmium::OSMEntity& item, THandler& handler) { inline void apply_item_recurse(osmium::OSMEntity& item, THandler& handler) {
switch (item.type()) { switch (item.type()) {
case osmium::item_type::node: case osmium::item_type::node:
handler.osm_object(static_cast<osmium::OSMObject&>(item)); handler.osm_object(static_cast<osmium::OSMObject&>(item));
handler.node(static_cast<osmium::Node&>(item)); handler.node(static_cast<osmium::Node&>(item));
break; break;
case osmium::item_type::way: case osmium::item_type::way:
handler.osm_object(static_cast<osmium::OSMObject&>(item)); handler.osm_object(static_cast<osmium::OSMObject&>(item));
handler.way(static_cast<osmium::Way&>(item)); handler.way(static_cast<osmium::Way&>(item));
break; break;
case osmium::item_type::relation: case osmium::item_type::relation:
handler.osm_object(static_cast<osmium::OSMObject&>(item)); handler.osm_object(static_cast<osmium::OSMObject&>(item));
handler.relation(static_cast<osmium::Relation&>(item)); handler.relation(static_cast<osmium::Relation&>(item));
break; break;
case osmium::item_type::area: case osmium::item_type::area:
handler.osm_object(static_cast<osmium::OSMObject&>(item)); handler.osm_object(static_cast<osmium::OSMObject&>(item));
handler.area(static_cast<osmium::Area&>(item)); handler.area(static_cast<osmium::Area&>(item));
break; break;
case osmium::item_type::changeset: case osmium::item_type::changeset:
handler.changeset(static_cast<osmium::Changeset&>(item)); handler.changeset(static_cast<osmium::Changeset&>(item));
break; break;
default: default:
throw osmium::unknown_type(); throw osmium::unknown_type();
} }
} }
template <class THandler> template <class THandler>
inline void apply_item_recurse(const osmium::OSMObject& item, THandler& handler) { inline void apply_item_recurse(const osmium::OSMObject& item, THandler& handler) {
switch (item.type()) { switch (item.type()) {
case osmium::item_type::node: case osmium::item_type::node:
handler.osm_object(item); handler.osm_object(item);
handler.node(static_cast<const osmium::Node&>(item)); handler.node(static_cast<const osmium::Node&>(item));
break; break;
case osmium::item_type::way: case osmium::item_type::way:
handler.osm_object(item); handler.osm_object(item);
handler.way(static_cast<const osmium::Way&>(item)); handler.way(static_cast<const osmium::Way&>(item));
break; break;
case osmium::item_type::relation: case osmium::item_type::relation:
handler.osm_object(item); handler.osm_object(item);
handler.relation(static_cast<const osmium::Relation&>(item)); handler.relation(static_cast<const osmium::Relation&>(item));
break; break;
case osmium::item_type::area: case osmium::item_type::area:
handler.osm_object(item); handler.osm_object(item);
handler.area(static_cast<const osmium::Area&>(item)); handler.area(static_cast<const osmium::Area&>(item));
break; break;
default: default:
throw osmium::unknown_type(); throw osmium::unknown_type();
} }
} }
template <class THandler> template <class THandler>
inline void apply_item_recurse(osmium::OSMObject& item, THandler& handler) { inline void apply_item_recurse(osmium::OSMObject& item, THandler& handler) {
switch (item.type()) { switch (item.type()) {
case osmium::item_type::node: case osmium::item_type::node:
handler.osm_object(item); handler.osm_object(item);
handler.node(static_cast<osmium::Node&>(item)); handler.node(static_cast<osmium::Node&>(item));
break; break;
case osmium::item_type::way: case osmium::item_type::way:
handler.osm_object(item); handler.osm_object(item);
handler.way(static_cast<osmium::Way&>(item)); handler.way(static_cast<osmium::Way&>(item));
break; break;
case osmium::item_type::relation: case osmium::item_type::relation:
handler.osm_object(item); handler.osm_object(item);
handler.relation(static_cast<osmium::Relation&>(item)); handler.relation(static_cast<osmium::Relation&>(item));
break; break;
case osmium::item_type::area: case osmium::item_type::area:
handler.osm_object(item); handler.osm_object(item);
handler.area(static_cast<osmium::Area&>(item)); handler.area(static_cast<osmium::Area&>(item));
break; break;
default: default:
throw osmium::unknown_type(); throw osmium::unknown_type();
} }
} }
template <class THandler, class TItem, class ...TRest> template <class THandler, class TItem, class ...TRest>
inline void apply_item_recurse(TItem& item, THandler& handler, TRest&... more) { inline void apply_item_recurse(TItem& item, THandler& handler, TRest&... more) {
apply_item_recurse(item, handler); apply_item_recurse(item, handler);
apply_item_recurse(item, more...); apply_item_recurse(item, more...);
} }
template <class THandler> template <class THandler>
inline void flush_recurse(THandler& handler) { inline void flush_recurse(THandler& handler) {
handler.flush(); handler.flush();
} }
template <class THandler, class ...TRest> template <class THandler, class ...TRest>
inline void flush_recurse(THandler& handler, TRest&... more) { inline void flush_recurse(THandler& handler, TRest&... more) {
flush_recurse(handler); flush_recurse(handler);
flush_recurse(more...); flush_recurse(more...);
} }
} // namespace detail } // namespace detail
template <class ...THandlers> template <class ...THandlers>
inline void apply_item(const osmium::memory::Item& item, THandlers&... handlers) { inline void apply_item(const osmium::memory::Item& item, THandlers&... handlers) {
detail::apply_item_recurse(item, handlers...); detail::apply_item_recurse(item, handlers...);
} }
template <class ...THandlers> template <class ...THandlers>
inline void apply_item(osmium::memory::Item& item, THandlers&... handlers) { inline void apply_item(osmium::memory::Item& item, THandlers&... handlers) {
detail::apply_item_recurse(item, handlers...); detail::apply_item_recurse(item, handlers...);
} }
template <class TIterator, class ...THandlers> template <class TIterator, class ...THandlers>
inline void apply(TIterator it, TIterator end, THandlers&... handlers) { inline void apply(TIterator it, TIterator end, THandlers&... handlers) {
for (; it != end; ++it) { for (; it != end; ++it) {
detail::apply_item_recurse(*it, handlers...); detail::apply_item_recurse(*it, handlers...);
} }
detail::flush_recurse(handlers...); detail::flush_recurse(handlers...);
} }
template <class TContainer, class ...THandlers> template <class TContainer, class ...THandlers>
inline void apply(TContainer& c, THandlers&... handlers) { inline void apply(TContainer& c, THandlers&... handlers) {
apply(std::begin(c), std::end(c), handlers...); apply(std::begin(c), std::end(c), handlers...);
} }
template <class ...THandlers> template <class ...THandlers>
inline void apply(const osmium::memory::Buffer& buffer, THandlers&... handlers) { inline void apply(const osmium::memory::Buffer& buffer, THandlers&... handlers) {
apply(buffer.cbegin(), buffer.cend(), handlers...); apply(buffer.cbegin(), buffer.cend(), handlers...);
} }
} // namespace osmium } // namespace osmium
#endif // OSMIUM_VISITOR_HPP #endif // OSMIUM_VISITOR_HPP