Merge commit '8511256779228db8d2ffed7ccced2b53c70be248' as 'third_party/libosmium'

third_party/libosmium/include/gdalcpp.hpp

@@ -0,0 +1,406 @@
+#ifndef GDALCPP_HPP
+#define GDALCPP_HPP
+
+/*
+
+C++11 wrapper classes for GDAL/OGR.
+
+Version 1.1.1
+
+https://github.com/joto/gdalcpp
+
+Copyright 2015 Jochen Topf <jochen@topf.org>
+
+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 <algorithm>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include <gdal_priv.h>
+#include <gdal_version.h>
+#include <ogr_api.h>
+#include <ogrsf_frmts.h>
+
+namespace gdalcpp {
+
+#if GDAL_VERSION_MAJOR >= 2
+    using gdal_driver_type = GDALDriver;
+    using gdal_dataset_type = GDALDataset;
+#else
+    using gdal_driver_type = OGRSFDriver;
+    using gdal_dataset_type = OGRDataSource;
+#endif
+
+    /**
+     * Exception thrown for all errors in this class.
+     */
+    class gdal_error : public std::runtime_error {
+
+        std::string m_driver;
+        std::string m_dataset;
+        std::string m_layer;
+        std::string m_field;
+        OGRErr m_error;
+
+    public:
+
+        gdal_error(const std::string& message,
+                   OGRErr error,
+                   const std::string& driver = "",
+                   const std::string& dataset = "",
+                   const std::string& layer = "",
+                   const std::string& field = "") :
+            std::runtime_error(message),
+            m_driver(driver),
+            m_dataset(dataset),
+            m_layer(layer),
+            m_field(field),
+            m_error(error) {
+        }
+
+        const std::string& driver() const {
+            return m_driver;
+        }
+
+        const std::string& dataset() const {
+            return m_dataset;
+        }
+
+        const std::string& layer() const {
+            return m_layer;
+        }
+
+        const std::string& field() const {
+            return m_field;
+        }
+
+        OGRErr error() const {
+            return m_error;
+        }
+
+    }; // class gdal_error
+
+    namespace detail {
+
+        struct init_wrapper {
+            init_wrapper() { OGRRegisterAll(); }
+            ~init_wrapper() { OGRCleanupAll(); }
+        };
+
+        struct init_library {
+            init_library() {
+                static init_wrapper iw;
+            }
+        };
+
+        class Driver : private init_library {
+
+            gdal_driver_type* m_driver;
+
+        public:
+
+            Driver(const std::string& driver_name) :
+                init_library(),
+#if GDAL_VERSION_MAJOR >= 2
+                m_driver(GetGDALDriverManager()->GetDriverByName(driver_name.c_str())) {
+#else
+                m_driver(OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(driver_name.c_str())) {
+#endif
+                if (!m_driver) {
+                    throw gdal_error(std::string("unknown driver: '") + driver_name + "'", OGRERR_NONE, driver_name);
+                }
+            }
+
+            gdal_driver_type& get() const {
+                return *m_driver;
+            }
+
+        }; // struct Driver
+
+        struct Options {
+
+            std::vector<std::string> m_options;
+            std::unique_ptr<const char*[]> m_ptrs;
+
+            Options(const std::vector<std::string>& options) :
+                m_options(options),
+                m_ptrs(new const char*[options.size()+1]) {
+                std::transform(m_options.begin(), m_options.end(), m_ptrs.get(), [&](const std::string& s) {
+                    return s.data();
+                });
+                m_ptrs[options.size()] = nullptr;
+            }
+
+            char** get() const {
+                return const_cast<char**>(m_ptrs.get());
+            }
+
+        }; // struct Options
+
+    } // namespace detail
+
+    class SRS {
+
+        OGRSpatialReference m_spatial_reference;
+
+    public:
+
+        SRS() :
+            m_spatial_reference() {
+            auto result = m_spatial_reference.SetWellKnownGeogCS("WGS84");
+            if (result != OGRERR_NONE) {
+                throw gdal_error(std::string("can not initialize spatial reference system WGS84"), result);
+            }
+        }
+
+        explicit SRS(int epsg) :
+            m_spatial_reference() {
+            auto result = m_spatial_reference.importFromEPSG(epsg);
+            if (result != OGRERR_NONE) {
+                throw gdal_error(std::string("can not initialize spatial reference system for EPSG:") + std::to_string(epsg), result);
+            }
+        }
+
+        explicit SRS(const char* name) :
+            m_spatial_reference() {
+            auto result = m_spatial_reference.importFromProj4(name);
+            if (result != OGRERR_NONE) {
+                throw gdal_error(std::string("can not initialize spatial reference system '") + name + "'", result);
+            }
+        }
+
+        explicit SRS(const std::string& name) :
+            m_spatial_reference() {
+            auto result = m_spatial_reference.importFromProj4(name.c_str());
+            if (result != OGRERR_NONE) {
+                throw gdal_error(std::string("can not initialize spatial reference system '") + name + "'", result);
+            }
+        }
+
+        explicit SRS(const OGRSpatialReference& spatial_reference) :
+            m_spatial_reference(spatial_reference) {
+        }
+
+        OGRSpatialReference& get() {
+            return m_spatial_reference;
+        }
+
+        const OGRSpatialReference& get() const {
+            return m_spatial_reference;
+        }
+
+    }; // class SRS
+
+    class Dataset {
+
+        struct gdal_dataset_deleter {
+
+            void operator()(gdal_dataset_type* ds) {
+#if GDAL_VERSION_MAJOR >= 2
+                GDALClose(ds);
+#else
+                OGRDataSource::DestroyDataSource(ds);
+#endif
+            }
+
+        }; // struct gdal_dataset_deleter
+
+        std::string m_driver_name;
+        std::string m_dataset_name;
+        detail::Options m_options;
+        SRS m_srs;
+        std::unique_ptr<gdal_dataset_type, gdal_dataset_deleter> m_dataset;
+
+    public:
+
+        Dataset(const std::string& driver_name, const std::string& dataset_name, const SRS& srs = SRS{}, const std::vector<std::string>& options = {}) :
+            m_driver_name(driver_name),
+            m_dataset_name(dataset_name),
+            m_options(options),
+            m_srs(srs),
+#if GDAL_VERSION_MAJOR >= 2
+            m_dataset(detail::Driver(driver_name).get().Create(dataset_name.c_str(), 0, 0, 0, GDT_Unknown, m_options.get())) {
+#else
+            m_dataset(detail::Driver(driver_name).get().CreateDataSource(dataset_name.c_str(), m_options.get())) {
+#endif
+            if (!m_dataset) {
+                throw gdal_error(std::string("failed to create dataset '") + dataset_name + "'", OGRERR_NONE, driver_name, dataset_name);
+            }
+        }
+
+        const std::string& driver_name() const {
+            return m_driver_name;
+        }
+
+        const std::string& dataset_name() const {
+            return m_dataset_name;
+        }
+
+        gdal_dataset_type& get() const {
+            return *m_dataset;
+        }
+
+        SRS& srs() {
+            return m_srs;
+        }
+
+        void exec(const char* sql) {
+            auto result = m_dataset->ExecuteSQL(sql, nullptr, nullptr);
+            if (result) {
+                m_dataset->ReleaseResultSet(result);
+            }
+        }
+
+        void exec(const std::string& sql) {
+            exec(sql.c_str());
+        }
+
+
+        Dataset& start_transaction() {
+#if GDAL_VERSION_MAJOR >= 2
+            m_dataset->StartTransaction();
+#endif
+            return *this;
+        }
+
+        Dataset& commit_transaction() {
+#if GDAL_VERSION_MAJOR >= 2
+            m_dataset->CommitTransaction();
+#endif
+            return *this;
+        }
+
+    }; // class Dataset
+
+    class Layer {
+
+        detail::Options m_options;
+        Dataset& m_dataset;
+        OGRLayer* m_layer;
+
+    public:
+
+        Layer(Dataset& dataset, const std::string& layer_name, OGRwkbGeometryType type, const std::vector<std::string>& options = {}) :
+            m_options(options),
+            m_dataset(dataset),
+            m_layer(dataset.get().CreateLayer(layer_name.c_str(), &dataset.srs().get(), type, m_options.get())) {
+            if (!m_layer) {
+                throw gdal_error(std::string("failed to create layer '") + layer_name + "'", OGRERR_NONE,
+                    dataset.driver_name(), dataset.dataset_name(), layer_name);
+            }
+        }
+
+        OGRLayer& get() {
+            return *m_layer;
+        }
+
+        const OGRLayer& get() const {
+            return *m_layer;
+        }
+
+        Dataset& dataset() const {
+            return m_dataset;
+        }
+
+        const char* name() const {
+            return m_layer->GetName();
+        }
+
+        Layer& add_field(const std::string& field_name, OGRFieldType type, int width, int precision=0) {
+            OGRFieldDefn field(field_name.c_str(), type);
+            field.SetWidth(width);
+            field.SetPrecision(precision);
+
+            if (m_layer->CreateField(&field) != OGRERR_NONE) {
+                throw gdal_error(std::string("failed to create field '") + field_name + "' in layer '" + name() + "'", OGRERR_NONE,
+                    m_dataset.driver_name(), m_dataset.dataset_name(), name(), field_name);
+            }
+
+            return *this;
+        }
+
+        Layer& start_transaction() {
+            OGRErr result = m_layer->StartTransaction();
+            if (result != OGRERR_NONE) {
+                throw gdal_error(std::string("starting transaction on layer '") + name() + "' failed", result, m_dataset.driver_name(), m_dataset.dataset_name(), name());
+            }
+            return *this;
+        }
+
+        Layer& commit_transaction() {
+            OGRErr result = m_layer->CommitTransaction();
+            if (result != OGRERR_NONE) {
+                throw gdal_error(std::string("committing transaction on layer '") + name() + "' failed", result, m_dataset.driver_name(), m_dataset.dataset_name(), name());
+            }
+            return *this;
+         }
+
+    }; // class Layer
+
+    class Feature {
+
+        Layer& m_layer;
+        OGRFeature m_feature;
+
+    public:
+
+        Feature(Layer& layer, std::unique_ptr<OGRGeometry>&& geometry) :
+            m_layer(layer),
+            m_feature(m_layer.get().GetLayerDefn()) {
+            OGRErr result = m_feature.SetGeometryDirectly(geometry.release());
+            if (result != OGRERR_NONE) {
+                throw gdal_error(std::string("setting feature geometry in layer '") + m_layer.name() + "' failed", result, m_layer.dataset().driver_name(), m_layer.dataset().dataset_name());
+            }
+        }
+
+        void add_to_layer() {
+            OGRErr result = m_layer.get().CreateFeature(&m_feature);
+            if (result != OGRERR_NONE) {
+                throw gdal_error(std::string("creating feature in layer '") + m_layer.name() + "' failed", result, m_layer.dataset().driver_name(), m_layer.dataset().dataset_name());
+            }
+        }
+
+        template <class T>
+        Feature& set_field(int n, T&& arg) {
+            m_feature.SetField(n, std::forward<T>(arg));
+            return *this;
+        }
+
+        template <class T>
+        Feature& set_field(const char* name, T&& arg) {
+            m_feature.SetField(name, std::forward<T>(arg));
+            return *this;
+        }
+
+    }; // class Feature
+
+} // namespace gdalcpp
+
+#endif // GDALCPP_HPP

third_party/libosmium/include/osmium/area/assembler.hpp

@@ -0,0 +1,787 @@
+#ifndef OSMIUM_AREA_ASSEMBLER_HPP
+#define OSMIUM_AREA_ASSEMBLER_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <algorithm>
+#include <cassert>
+#include <cstring>
+#include <iostream>
+#include <iterator>
+#include <list>
+#include <set>
+#include <string>
+#include <map>
+#include <vector>
+
+#include <osmium/builder/osm_object_builder.hpp>
+#include <osmium/memory/buffer.hpp>
+#include <osmium/osm/area.hpp>
+#include <osmium/osm/location.hpp>
+#include <osmium/osm/relation.hpp>
+#include <osmium/tags/filter.hpp>
+
+#include <osmium/area/detail/proto_ring.hpp>
+#include <osmium/area/detail/node_ref_segment.hpp>
+#include <osmium/area/detail/segment_list.hpp>
+#include <osmium/area/problem_reporter.hpp>
+
+namespace osmium {
+
+    namespace area {
+
+        using osmium::area::detail::ProtoRing;
+
+        struct AssemblerConfig {
+
+            osmium::area::ProblemReporter* problem_reporter;
+
+            // Enables debug output to stderr
+            bool debug;
+
+            explicit AssemblerConfig(osmium::area::ProblemReporter* pr = nullptr, bool d = false) :
+                problem_reporter(pr),
+                debug(d) {
+            }
+
+            /**
+             * Enable or disable debug output to stderr. This is for Osmium
+             * developers only.
+             */
+            void enable_debug_output(bool d = true) {
+                debug = d;
+            }
+
+        }; // struct AssemblerConfig
+
+        /**
+         * Assembles area objects from multipolygon relations and their
+         * members. This is called by the MultipolygonCollector object
+         * after all members have been collected.
+         */
+        class Assembler {
+
+            const AssemblerConfig m_config;
+
+            // The way segments
+            osmium::area::detail::SegmentList m_segment_list;
+
+            // The rings we are building from the way segments
+            std::list<ProtoRing> m_rings;
+
+            std::vector<ProtoRing*> m_outer_rings;
+            std::vector<ProtoRing*> m_inner_rings;
+
+            int m_inner_outer_mismatches { 0 };
+
+            bool debug() const {
+                return m_config.debug;
+            }
+
+            /**
+             * Checks whether the given NodeRefs have the same location.
+             * Uses the actual location for the test, not the id. If both
+             * have the same location, but not the same id, a problem
+             * point will be added to the list of problem points.
+             */
+            bool has_same_location(const osmium::NodeRef& nr1, const osmium::NodeRef& nr2) {
+                if (nr1.location() != nr2.location()) {
+                    return false;
+                }
+                if (nr1.ref() != nr2.ref()) {
+                    if (m_config.problem_reporter) {
+                        m_config.problem_reporter->report_duplicate_node(nr1.ref(), nr2.ref(), nr1.location());
+                    }
+                }
+                return true;
+            }
+
+            void add_tags_to_area(osmium::builder::AreaBuilder& builder, const osmium::Way& way) const {
+                osmium::builder::TagListBuilder tl_builder(builder.buffer(), &builder);
+                for (const osmium::Tag& tag : way.tags()) {
+                    tl_builder.add_tag(tag.key(), tag.value());
+                }
+            }
+
+            void add_common_tags(osmium::builder::TagListBuilder& tl_builder, std::set<const osmium::Way*>& ways) const {
+                std::map<std::string, size_t> counter;
+                for (const osmium::Way* way : ways) {
+                    for (const auto& tag : way->tags()) {
+                        std::string kv {tag.key()};
+                        kv.append(1, '\0');
+                        kv.append(tag.value());
+                        ++counter[kv];
+                    }
+                }
+
+                size_t num_ways = ways.size();
+                for (const auto& t_c : counter) {
+                    if (debug()) {
+                        std::cerr << "        tag " << t_c.first << " is used " << t_c.second << " times in " << num_ways << " ways\n";
+                    }
+                    if (t_c.second == num_ways) {
+                        size_t len = std::strlen(t_c.first.c_str());
+                        tl_builder.add_tag(t_c.first.c_str(), t_c.first.c_str() + len + 1);
+                    }
+                }
+            }
+
+            struct MPFilter : public osmium::tags::KeyFilter {
+
+                MPFilter() : osmium::tags::KeyFilter(true) {
+                    add(false, "type");
+                    add(false, "created_by");
+                    add(false, "source");
+                    add(false, "note");
+                    add(false, "test:id");
+                    add(false, "test:section");
+                }
+
+            }; // struct MPFilter
+
+            static MPFilter& filter() {
+                static MPFilter filter;
+                return filter;
+            }
+
+            void add_tags_to_area(osmium::builder::AreaBuilder& builder, const osmium::Relation& relation) const {
+                const auto count = std::count_if(relation.tags().begin(), relation.tags().end(), filter());
+
+                if (debug()) {
+                    std::cerr << "  found " << count << " tags on relation (without ignored ones)\n";
+                }
+
+                if (count > 0) {
+                    if (debug()) {
+                        std::cerr << "    use tags from relation\n";
+                    }
+
+                    // write out all tags except type=*
+                    osmium::builder::TagListBuilder tl_builder(builder.buffer(), &builder);
+                    for (const osmium::Tag& tag : relation.tags()) {
+                        if (strcmp(tag.key(), "type")) {
+                            tl_builder.add_tag(tag.key(), tag.value());
+                        }
+                    }
+                } else {
+                    if (debug()) {
+                        std::cerr << "    use tags from outer ways\n";
+                    }
+                    std::set<const osmium::Way*> ways;
+                    for (const auto& ring : m_outer_rings) {
+                        ring->get_ways(ways);
+                    }
+                    if (ways.size() == 1) {
+                        if (debug()) {
+                            std::cerr << "      only one outer way\n";
+                        }
+                        osmium::builder::TagListBuilder tl_builder(builder.buffer(), &builder);
+                        for (const osmium::Tag& tag : (*ways.begin())->tags()) {
+                            tl_builder.add_tag(tag.key(), tag.value());
+                        }
+                    } else {
+                        if (debug()) {
+                            std::cerr << "      multiple outer ways, get common tags\n";
+                        }
+                        osmium::builder::TagListBuilder tl_builder(builder.buffer(), &builder);
+                        add_common_tags(tl_builder, ways);
+                    }
+                }
+            }
+
+            /**
+             * Go through all the rings and find rings that are not closed.
+             * Problems are reported through the problem reporter.
+             *
+             * @returns true if any rings were not closed, false otherwise
+             */
+            bool check_for_open_rings() {
+                bool open_rings = false;
+
+                for (const auto& ring : m_rings) {
+                    if (!ring.closed()) {
+                        open_rings = true;
+                        if (m_config.problem_reporter) {
+                            m_config.problem_reporter->report_ring_not_closed(ring.get_node_ref_front().location(), ring.get_node_ref_back().location());
+                        }
+                    }
+                }
+
+                return open_rings;
+            }
+
+            /**
+             * Check whether there are any rings that can be combined with the
+             * given ring to one larger ring by appending the other ring to
+             * the end of this ring.
+             * If the rings can be combined they are and the function returns
+             * true.
+             */
+            bool possibly_combine_rings_back(ProtoRing& ring) {
+                const osmium::NodeRef& nr = ring.get_node_ref_back();
+
+                if (debug()) {
+                    std::cerr << "      possibly_combine_rings_back()\n";
+                }
+                for (auto it = m_rings.begin(); it != m_rings.end(); ++it) {
+                    if (&*it != &ring && !it->closed()) {
+                        if (has_same_location(nr, it->get_node_ref_front())) {
+                            if (debug()) {
+                                std::cerr << "      ring.last=it->first\n";
+                            }
+                            ring.merge_ring(*it, debug());
+                            m_rings.erase(it);
+                            return true;
+                        }
+                        if (has_same_location(nr, it->get_node_ref_back())) {
+                            if (debug()) {
+                                std::cerr << "      ring.last=it->last\n";
+                            }
+                            ring.merge_ring_reverse(*it, debug());
+                            m_rings.erase(it);
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            }
+
+            /**
+             * Check whether there are any rings that can be combined with the
+             * given ring to one larger ring by prepending the other ring to
+             * the start of this ring.
+             * If the rings can be combined they are and the function returns
+             * true.
+             */
+            bool possibly_combine_rings_front(ProtoRing& ring) {
+                const osmium::NodeRef& nr = ring.get_node_ref_front();
+
+                if (debug()) {
+                    std::cerr << "      possibly_combine_rings_front()\n";
+                }
+                for (auto it = m_rings.begin(); it != m_rings.end(); ++it) {
+                    if (&*it != &ring && !it->closed()) {
+                        if (has_same_location(nr, it->get_node_ref_back())) {
+                            if (debug()) {
+                                std::cerr << "      ring.first=it->last\n";
+                            }
+                            ring.swap_segments(*it);
+                            ring.merge_ring(*it, debug());
+                            m_rings.erase(it);
+                            return true;
+                        }
+                        if (has_same_location(nr, it->get_node_ref_front())) {
+                            if (debug()) {
+                                std::cerr << "      ring.first=it->first\n";
+                            }
+                            ring.reverse();
+                            ring.merge_ring(*it, debug());
+                            m_rings.erase(it);
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            }
+
+            void split_off_subring(osmium::area::detail::ProtoRing& ring, osmium::area::detail::ProtoRing::segments_type::iterator it, osmium::area::detail::ProtoRing::segments_type::iterator it_begin, osmium::area::detail::ProtoRing::segments_type::iterator it_end) {
+                if (debug()) {
+                    std::cerr << "        subring found at: " << *it << "\n";
+                }
+                ProtoRing new_ring(it_begin, it_end);
+                ring.remove_segments(it_begin, it_end);
+                if (debug()) {
+                    std::cerr << "        split into two rings:\n";
+                    std::cerr << "          " << new_ring << "\n";
+                    std::cerr << "          " << ring << "\n";
+                }
+                m_rings.push_back(std::move(new_ring));
+            }
+
+            bool has_closed_subring_back(ProtoRing& ring, const NodeRef& nr) {
+                if (ring.segments().size() < 3) {
+                    return false;
+                }
+                if (debug()) {
+                    std::cerr << "      has_closed_subring_back()\n";
+                }
+                const auto end = ring.segments().end();
+                for (auto it = ring.segments().begin() + 1; it != end - 1; ++it) {
+                    if (has_same_location(nr, it->first())) {
+                        split_off_subring(ring, it, it, end);
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            bool has_closed_subring_front(ProtoRing& ring, const NodeRef& nr) {
+                if (ring.segments().size() < 3) {
+                    return false;
+                }
+                if (debug()) {
+                    std::cerr << "      has_closed_subring_front()\n";
+                }
+                const auto end = ring.segments().end();
+                for (auto it = ring.segments().begin() + 1; it != end - 1; ++it) {
+                    if (has_same_location(nr, it->second())) {
+                        split_off_subring(ring, it, ring.segments().begin(), it+1);
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            bool check_for_closed_subring(ProtoRing& ring) {
+                if (debug()) {
+                    std::cerr << "      check_for_closed_subring()\n";
+                }
+
+                osmium::area::detail::ProtoRing::segments_type segments(ring.segments().size());
+                std::copy(ring.segments().cbegin(), ring.segments().cend(), segments.begin());
+                std::sort(segments.begin(), segments.end());
+                const auto it = std::adjacent_find(segments.begin(), segments.end(), [this](const osmium::area::detail::NodeRefSegment& s1, const osmium::area::detail::NodeRefSegment& s2) {
+                    return has_same_location(s1.first(), s2.first());
+                });
+                if (it == segments.end()) {
+                    return false;
+                }
+                const auto r1 = std::find_first_of(ring.segments().begin(), ring.segments().end(), it, it+1);
+                assert(r1 != ring.segments().end());
+                const auto r2 = std::find_first_of(ring.segments().begin(), ring.segments().end(), it+1, it+2);
+                assert(r2 != ring.segments().end());
+
+                if (debug()) {
+                    std::cerr << "      found subring in ring " << ring << " at " << it->first() << "\n";
+                }
+
+                const auto m = std::minmax(r1, r2);
+
+                ProtoRing new_ring(m.first, m.second);
+                ring.remove_segments(m.first, m.second);
+
+                if (debug()) {
+                    std::cerr << "        split ring1=" << new_ring << "\n";
+                    std::cerr << "        split ring2=" << ring << "\n";
+                }
+
+                m_rings.emplace_back(new_ring);
+
+                return true;
+            }
+
+            void combine_rings_front(const osmium::area::detail::NodeRefSegment& segment, ProtoRing& ring) {
+                if (debug()) {
+                    std::cerr << " => match at front of ring\n";
+                }
+                ring.add_segment_front(segment);
+                has_closed_subring_front(ring, segment.first());
+                if (possibly_combine_rings_front(ring)) {
+                    check_for_closed_subring(ring);
+                }
+            }
+
+            void combine_rings_back(const osmium::area::detail::NodeRefSegment& segment, ProtoRing& ring) {
+                if (debug()) {
+                    std::cerr << " => match at back of ring\n";
+                }
+                ring.add_segment_back(segment);
+                has_closed_subring_back(ring, segment.second());
+                if (possibly_combine_rings_back(ring)) {
+                    check_for_closed_subring(ring);
+                }
+            }
+
+            /**
+             * Append each outer ring together with its inner rings to the
+             * area in the buffer.
+             */
+            void add_rings_to_area(osmium::builder::AreaBuilder& builder) const {
+                for (const ProtoRing* ring : m_outer_rings) {
+                    if (debug()) {
+                        std::cerr << "    ring " << *ring << " is outer\n";
+                    }
+                    {
+                        osmium::builder::OuterRingBuilder ring_builder(builder.buffer(), &builder);
+                        ring_builder.add_node_ref(ring->get_node_ref_front());
+                        for (const auto& segment : ring->segments()) {
+                            ring_builder.add_node_ref(segment.second());
+                        }
+                    }
+                    for (ProtoRing* inner : ring->inner_rings()) {
+                        osmium::builder::InnerRingBuilder ring_builder(builder.buffer(), &builder);
+                        ring_builder.add_node_ref(inner->get_node_ref_front());
+                        for (const auto& segment : inner->segments()) {
+                            ring_builder.add_node_ref(segment.second());
+                        }
+                    }
+                }
+            }
+
+            bool add_to_existing_ring(osmium::area::detail::NodeRefSegment segment) {
+                int n = 0;
+                for (auto& ring : m_rings) {
+                    if (debug()) {
+                        std::cerr << "    check against ring " << n << " " << ring;
+                    }
+                    if (ring.closed()) {
+                        if (debug()) {
+                            std::cerr << " => ring CLOSED\n";
+                        }
+                    } else {
+                        if (has_same_location(ring.get_node_ref_back(), segment.first())) {
+                            combine_rings_back(segment, ring);
+                            return true;
+                        }
+                        if (has_same_location(ring.get_node_ref_back(), segment.second())) {
+                            segment.swap_locations();
+                            combine_rings_back(segment, ring);
+                            return true;
+                        }
+                        if (has_same_location(ring.get_node_ref_front(), segment.first())) {
+                            segment.swap_locations();
+                            combine_rings_front(segment, ring);
+                            return true;
+                        }
+                        if (has_same_location(ring.get_node_ref_front(), segment.second())) {
+                            combine_rings_front(segment, ring);
+                            return true;
+                        }
+                        if (debug()) {
+                            std::cerr << " => no match\n";
+                        }
+                    }
+
+                    ++n;
+                }
+                return false;
+            }
+
+            void check_inner_outer(ProtoRing& ring) {
+                const osmium::NodeRef& min_node = ring.min_node();
+                if (debug()) {
+                    std::cerr << "    check_inner_outer min_node=" << min_node << "\n";
+                }
+
+                int count = 0;
+                int above = 0;
+
+                for (auto it = m_segment_list.begin(); it != m_segment_list.end() && it->first().location().x() <= min_node.location().x(); ++it) {
+                    if (!ring.contains(*it)) {
+                        if (debug()) {
+                            std::cerr << "      segments for count: " << *it;
+                        }
+                        if (it->to_left_of(min_node.location())) {
+                            ++count;
+                            if (debug()) {
+                                std::cerr << " counted\n";
+                            }
+                        } else {
+                            if (debug()) {
+                                std::cerr << " not counted\n";
+                            }
+                        }
+                        if (it->first().location() == min_node.location()) {
+                            if (it->second().location().y() > min_node.location().y()) {
+                                ++above;
+                            }
+                        }
+                        if (it->second().location() == min_node.location()) {
+                            if (it->first().location().y() > min_node.location().y()) {
+                                ++above;
+                            }
+                        }
+                    }
+                }
+
+                if (debug()) {
+                    std::cerr << "      count=" << count << " above=" << above << "\n";
+                }
+
+                count += above % 2;
+
+                if (count % 2) {
+                    ring.set_inner();
+                }
+            }
+
+            void check_inner_outer_roles() {
+                if (debug()) {
+                    std::cerr << "    check_inner_outer_roles\n";
+                }
+
+                for (const auto ringptr : m_outer_rings) {
+                    for (const auto& segment : ringptr->segments()) {
+                        if (!segment.role_outer()) {
+                            ++m_inner_outer_mismatches;
+                            if (debug()) {
+                                std::cerr << "      segment " << segment << " from way " << segment.way()->id() << " should have role 'outer'\n";
+                            }
+                            if (m_config.problem_reporter) {
+                                m_config.problem_reporter->report_role_should_be_outer(segment.way()->id(), segment.first().location(), segment.second().location());
+                            }
+                        }
+                    }
+                }
+                for (const auto ringptr : m_inner_rings) {
+                    for (const auto& segment : ringptr->segments()) {
+                        if (!segment.role_inner()) {
+                            ++m_inner_outer_mismatches;
+                            if (debug()) {
+                                std::cerr << "      segment " << segment << " from way " << segment.way()->id() << " should have role 'inner'\n";
+                            }
+                            if (m_config.problem_reporter) {
+                                m_config.problem_reporter->report_role_should_be_inner(segment.way()->id(), segment.first().location(), segment.second().location());
+                            }
+                        }
+                    }
+                }
+            }
+
+            /**
+             * Create rings from segments.
+             */
+            bool create_rings() {
+                m_segment_list.sort();
+                m_segment_list.erase_duplicate_segments();
+
+                // Now we look for segments crossing each other. If there are
+                // any, the multipolygon is invalid.
+                // In the future this could be improved by trying to fix those
+                // cases.
+                if (m_segment_list.find_intersections(m_config.problem_reporter)) {
+                    return false;
+                }
+
+                // Now iterator over all segments and add them to rings. Each segment
+                // is tacked on to either end of an existing ring if possible, or a
+                // new ring is started with it.
+                for (const auto& segment : m_segment_list) {
+                    if (debug()) {
+                        std::cerr << "  checking segment " << segment << "\n";
+                    }
+                    if (!add_to_existing_ring(segment)) {
+                        if (debug()) {
+                            std::cerr << "    new ring for segment " << segment << "\n";
+                        }
+                        m_rings.emplace_back(segment);
+                    }
+                }
+
+                if (debug()) {
+                    std::cerr << "  Rings:\n";
+                    for (const auto& ring : m_rings) {
+                        std::cerr << "    " << ring;
+                        if (ring.closed()) {
+                            std::cerr << " (closed)";
+                        }
+                        std::cerr << "\n";
+                    }
+                }
+
+                if (check_for_open_rings()) {
+                    if (debug()) {
+                        std::cerr << "  not all rings are closed\n";
+                    }
+                    return false;
+                }
+
+                if (debug()) {
+                    std::cerr << "  Find inner/outer...\n";
+                }
+
+                if (m_rings.size() == 1) {
+                    m_outer_rings.push_back(&m_rings.front());
+                } else {
+                    for (auto& ring : m_rings) {
+                        check_inner_outer(ring);
+                        if (ring.outer()) {
+                            if (!ring.is_cw()) {
+                                ring.reverse();
+                            }
+                            m_outer_rings.push_back(&ring);
+                        } else {
+                            if (ring.is_cw()) {
+                                ring.reverse();
+                            }
+                            m_inner_rings.push_back(&ring);
+                        }
+                    }
+
+                    if (m_outer_rings.size() == 1) {
+                        for (auto inner : m_inner_rings) {
+                            m_outer_rings.front()->add_inner_ring(inner);
+                        }
+                    } else {
+                        // sort outer rings by size, smallest first
+                        std::sort(m_outer_rings.begin(), m_outer_rings.end(), [](ProtoRing* a, ProtoRing* b) {
+                            return a->area() < b->area();
+                        });
+                        for (auto inner : m_inner_rings) {
+                            for (auto outer : m_outer_rings) {
+                                if (inner->is_in(outer)) {
+                                    outer->add_inner_ring(inner);
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+
+                check_inner_outer_roles();
+
+                return true;
+            }
+
+        public:
+
+            typedef osmium::area::AssemblerConfig config_type;
+
+            explicit Assembler(const config_type& config) :
+                m_config(config),
+                m_segment_list(config.debug) {
+            }
+
+            ~Assembler() = default;
+
+            /**
+             * Assemble an area from the given way.
+             * The resulting area is put into the out_buffer.
+             */
+            void operator()(const osmium::Way& way, osmium::memory::Buffer& out_buffer) {
+                if (m_config.problem_reporter) {
+                    m_config.problem_reporter->set_object(osmium::item_type::way, way.id());
+                }
+
+                if (!way.ends_have_same_id()) {
+                    if (m_config.problem_reporter) {
+                        m_config.problem_reporter->report_duplicate_node(way.nodes().front().ref(), way.nodes().back().ref(), way.nodes().front().location());
+                    }
+                }
+
+                m_segment_list.extract_segments_from_way(way, "outer");
+
+                if (debug()) {
+                    std::cerr << "\nBuild way id()=" << way.id() << " segments.size()=" << m_segment_list.size() << "\n";
+                }
+
+                // Now create the Area object and add the attributes and tags
+                // from the way.
+                {
+                    osmium::builder::AreaBuilder builder(out_buffer);
+                    builder.initialize_from_object(way);
+
+                    if (create_rings()) {
+                        add_tags_to_area(builder, way);
+                        add_rings_to_area(builder);
+                    }
+                }
+                out_buffer.commit();
+            }
+
+            /**
+             * Assemble an area from the given relation and its members.
+             * All members are to be found in the in_buffer at the offsets
+             * given by the members parameter.
+             * The resulting area is put into the out_buffer.
+             */
+            void operator()(const osmium::Relation& relation, const std::vector<size_t>& members, const osmium::memory::Buffer& in_buffer, osmium::memory::Buffer& out_buffer) {
+                if (m_config.problem_reporter) {
+                    m_config.problem_reporter->set_object(osmium::item_type::relation, relation.id());
+                }
+
+                m_segment_list.extract_segments_from_ways(relation, members, in_buffer);
+
+                if (debug()) {
+                    std::cerr << "\nBuild relation id()=" << relation.id() << " members.size()=" << members.size() << " segments.size()=" << m_segment_list.size() << "\n";
+                }
+
+                size_t area_offset = out_buffer.committed();
+
+                // Now create the Area object and add the attributes and tags
+                // from the relation.
+                {
+                    osmium::builder::AreaBuilder builder(out_buffer);
+                    builder.initialize_from_object(relation);
+
+                    if (create_rings()) {
+                        add_tags_to_area(builder, relation);
+                        add_rings_to_area(builder);
+                    }
+                }
+                out_buffer.commit();
+
+                const osmium::TagList& area_tags = out_buffer.get<osmium::Area>(area_offset).tags(); // tags of the area we just built
+
+                // Find all closed ways that are inner rings and check their
+                // tags. If they are not the same as the tags of the area we
+                // just built, add them to a list and later build areas for
+                // them, too.
+                std::vector<const osmium::Way*> ways_that_should_be_areas;
+                if (m_inner_outer_mismatches == 0) {
+                    auto memit = relation.members().begin();
+                    for (size_t offset : members) {
+                        if (!std::strcmp(memit->role(), "inner")) {
+                            const osmium::Way& way = in_buffer.get<const osmium::Way>(offset);
+                            if (!way.nodes().empty() && way.is_closed() && way.tags().size() > 0) {
+                                auto d = std::count_if(way.tags().begin(), way.tags().end(), filter());
+                                if (d > 0) {
+                                    osmium::tags::KeyFilter::iterator way_fi_begin(filter(), way.tags().begin(), way.tags().end());
+                                    osmium::tags::KeyFilter::iterator way_fi_end(filter(), way.tags().end(), way.tags().end());
+                                    osmium::tags::KeyFilter::iterator area_fi_begin(filter(), area_tags.begin(), area_tags.end());
+                                    osmium::tags::KeyFilter::iterator area_fi_end(filter(), area_tags.end(), area_tags.end());
+
+                                    if (!std::equal(way_fi_begin, way_fi_end, area_fi_begin) || d != std::distance(area_fi_begin, area_fi_end)) {
+                                        ways_that_should_be_areas.push_back(&way);
+                                    }
+                                }
+                            }
+                        }
+                        ++memit;
+                    }
+                }
+
+                // Now build areas for all ways found in the last step.
+                for (const osmium::Way* way : ways_that_should_be_areas) {
+                    Assembler assembler(m_config);
+                    assembler(*way, out_buffer);
+                }
+            }
+
+        }; // class Assembler
+
+    } // namespace area
+
+} // namespace osmium
+
+#endif // OSMIUM_AREA_ASSEMBLER_HPP

third_party/libosmium/include/osmium/area/detail/node_ref_segment.hpp

@@ -0,0 +1,274 @@
+#ifndef OSMIUM_AREA_DETAIL_NODE_REF_SEGMENT_HPP
+#define OSMIUM_AREA_DETAIL_NODE_REF_SEGMENT_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <algorithm>
+#include <cstdint>
+#include <cstring>
+#include <iosfwd>
+#include <utility>
+
+#include <osmium/osm/location.hpp>
+#include <osmium/osm/node_ref.hpp>
+
+namespace osmium {
+
+    class Way;
+
+    namespace area {
+
+        /**
+         * @brief Namespace for Osmium internal use
+         */
+        namespace detail {
+
+            /**
+             * This helper class for the Assembler class models a segment.
+             * Segments are the connection between
+             * two nodes and they all have their smaller coordinate at the
+             * beginning of the segment. Smaller, in this case, means smaller x
+             * coordinate, and if they are the same smaller y coordinate.
+             */
+            class NodeRefSegment {
+
+                osmium::NodeRef m_first;
+                osmium::NodeRef m_second;
+
+                /// Role of the member this segment was from.
+                const char* m_role;
+
+                /// Way this segment was from.
+                const osmium::Way* m_way;
+
+            public:
+
+                void swap_locations() {
+                    using std::swap;
+                    swap(m_first, m_second);
+                }
+
+                explicit NodeRefSegment() noexcept :
+                    m_first(),
+                    m_second(),
+                    m_role(nullptr),
+                    m_way(nullptr) {
+                }
+
+                explicit NodeRefSegment(const osmium::NodeRef& nr1, const osmium::NodeRef& nr2, const char* role, const osmium::Way* way) :
+                    m_first(nr1),
+                    m_second(nr2),
+                    m_role(role),
+                    m_way(way) {
+                    if (nr2.location() < nr1.location()) {
+                        swap_locations();
+                    }
+                }
+
+                NodeRefSegment(const NodeRefSegment&) = default;
+                NodeRefSegment(NodeRefSegment&&) = default;
+
+                NodeRefSegment& operator=(const NodeRefSegment&) = default;
+                NodeRefSegment& operator=(NodeRefSegment&&) = default;
+
+                ~NodeRefSegment() = default;
+
+                /// Return first NodeRef of Segment according to sorting order (bottom left to top right).
+                const osmium::NodeRef& first() const noexcept {
+                    return m_first;
+                }
+
+                /// Return second NodeRef of Segment according to sorting order (bottom left to top right).
+                const osmium::NodeRef& second() const noexcept {
+                    return m_second;
+                }
+
+                bool to_left_of(const osmium::Location& location) const {
+    //                std::cerr << "segment " << first() << "--" << second() << " to_left_of(" << location << "\n";
+
+                    if (first().location() == location || second().location() == location) {
+                        return false;
+                    }
+
+                    const std::pair<osmium::Location, osmium::Location> mm = std::minmax(first().location(), second().location(), [](const osmium::Location a, const osmium::Location b) {
+                        return a.y() < b.y();
+                    });
+
+                    if (mm.first.y() >= location.y() || mm.second.y() < location.y() || first().location().x() > location.x()) {
+    //                    std::cerr << "  false\n";
+                        return false;
+                    }
+
+                    int64_t ax = mm.first.x();
+                    int64_t bx = mm.second.x();
+                    int64_t lx = location.x();
+                    int64_t ay = mm.first.y();
+                    int64_t by = mm.second.y();
+                    int64_t ly = location.y();
+                    return ((bx - ax)*(ly - ay) - (by - ay)*(lx - ax)) <= 0;
+                }
+
+                bool role_outer() const noexcept {
+                    return !strcmp(m_role, "outer");
+                }
+
+                bool role_inner() const noexcept {
+                    return !strcmp(m_role, "inner");
+                }
+
+                const osmium::Way* way() const noexcept {
+                    return m_way;
+                }
+
+            }; // class NodeRefSegment
+
+            /// NodeRefSegments are equal if both their locations are equal
+            inline bool operator==(const NodeRefSegment& lhs, const NodeRefSegment& rhs) noexcept {
+                return lhs.first().location() == rhs.first().location() && lhs.second().location() == rhs.second().location();
+            }
+
+            inline bool operator!=(const NodeRefSegment& lhs, const NodeRefSegment& rhs) noexcept {
+                return ! (lhs == rhs);
+            }
+
+            /**
+             * NodeRefSegments are "smaller" if they are to the left and down of another
+             * segment. The first() location is checked first() and only if they have the
+             * same first() location the second() location is taken into account.
+             */
+            inline bool operator<(const NodeRefSegment& lhs, const NodeRefSegment& rhs) noexcept {
+                return (lhs.first().location() == rhs.first().location() && lhs.second().location() < rhs.second().location()) || lhs.first().location() < rhs.first().location();
+            }
+
+            inline bool operator>(const NodeRefSegment& lhs, const NodeRefSegment& rhs) noexcept {
+                return rhs < lhs;
+            }
+
+            inline bool operator<=(const NodeRefSegment& lhs, const NodeRefSegment& rhs) noexcept {
+                return ! (rhs < lhs);
+            }
+
+            inline bool operator>=(const NodeRefSegment& lhs, const NodeRefSegment& rhs) noexcept {
+                return ! (lhs < rhs);
+            }
+
+            template <typename TChar, typename TTraits>
+            inline std::basic_ostream<TChar, TTraits>& operator<<(std::basic_ostream<TChar, TTraits>& out, const NodeRefSegment& segment) {
+                return out << segment.first() << "--" << segment.second();
+            }
+
+            inline bool outside_x_range(const NodeRefSegment& s1, const NodeRefSegment& s2) noexcept {
+                if (s1.first().location().x() > s2.second().location().x()) {
+                    return true;
+                }
+                return false;
+            }
+
+            inline bool y_range_overlap(const NodeRefSegment& s1, const NodeRefSegment& s2) {
+                const std::pair<int32_t, int32_t> m1 = std::minmax(s1.first().location().y(), s1.second().location().y());
+                const std::pair<int32_t, int32_t> m2 = std::minmax(s2.first().location().y(), s2.second().location().y());
+                if (m1.first > m2.second || m2.first > m1.second) {
+                    return false;
+                }
+                return true;
+            }
+
+            /**
+             * Calculate the intersection between two NodeRefSegments. The
+             * result is returned as a Location. Note that because the Location
+             * uses integers with limited precision internally, the result
+             * might be slightly different than the numerically correct
+             * location.
+             *
+             * This function uses integer arithmentic as much as possible and
+             * will not work if the segments are longer than about half the
+             * planet. This shouldn't happen with real data, so it isn't a big
+             * problem.
+             *
+             * If the segments touch in one of their endpoints, it doesn't
+             * count as an intersection.
+             *
+             * If the segments intersect not in a single point but in multiple
+             * points, ie if they overlap, this is NOT detected.
+             *
+             * @returns Undefined osmium::Location if there is no intersection
+             *          or a defined Location if the segments intersect.
+             */
+            inline osmium::Location calculate_intersection(const NodeRefSegment& s1, const NodeRefSegment& s2) {
+                if (s1.first().location()  == s2.first().location()  ||
+                    s1.first().location()  == s2.second().location() ||
+                    s1.second().location() == s2.first().location()  ||
+                    s1.second().location() == s2.second().location()) {
+                    return osmium::Location();
+                }
+
+                int64_t s1ax = s1.first().x();
+                int64_t s1ay = s1.first().y();
+                int64_t s1bx = s1.second().x();
+                int64_t s1by = s1.second().y();
+                int64_t s2ax = s2.first().x();
+                int64_t s2ay = s2.first().y();
+                int64_t s2bx = s2.second().x();
+                int64_t s2by = s2.second().y();
+
+                int64_t d = (s2by - s2ay) * (s1bx - s1ax) -
+                            (s2bx - s2ax) * (s1by - s1ay);
+
+                if (d != 0) {
+                    int64_t na = (s2bx - s2ax) * (s1ay - s2ay) -
+                                 (s2by - s2ay) * (s1ax - s2ax);
+
+                    int64_t nb = (s1bx - s1ax) * (s1ay - s2ay) -
+                                 (s1by - s1ay) * (s1ax - s2ax);
+
+                    if ((d > 0 && na >= 0 && na <= d && nb >= 0 && nb <= d) ||
+                        (d < 0 && na <= 0 && na >= d && nb <= 0 && nb >= d)) {
+
+                        double ua = double(na) / d;
+                        int32_t ix = int32_t(s1ax + ua*(s1bx - s1ax));
+                        int32_t iy = int32_t(s1ay + ua*(s1by - s1ay));
+
+                        return osmium::Location(ix, iy);
+                    }
+                }
+
+                return osmium::Location();
+            }
+
+        } // namespace detail
+
+    } // namespace area
+
+} // namespace osmium
+
+#endif // OSMIUM_AREA_DETAIL_NODE_REF_SEGMENT_HPP

third_party/libosmium/include/osmium/area/detail/proto_ring.hpp

@@ -0,0 +1,285 @@
+#ifndef OSMIUM_AREA_DETAIL_PROTO_RING_HPP
+#define OSMIUM_AREA_DETAIL_PROTO_RING_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <algorithm>
+#include <cstdint>
+#include <cstdlib>
+#include <iostream>
+#include <iterator>
+#include <set>
+#include <vector>
+
+#include <osmium/osm/location.hpp>
+#include <osmium/osm/node_ref.hpp>
+#include <osmium/area/detail/node_ref_segment.hpp>
+
+namespace osmium {
+
+    namespace area {
+
+        namespace detail {
+
+            /**
+             * A ring in the process of being built by the Assembler object.
+             */
+            class ProtoRing {
+
+            public:
+
+                typedef std::vector<NodeRefSegment> segments_type;
+
+            private:
+
+                // segments in this ring
+                segments_type m_segments;
+
+                bool m_outer {true};
+
+                // if this is an outer ring, these point to it's inner rings (if any)
+                std::vector<ProtoRing*> m_inner;
+
+            public:
+
+                explicit ProtoRing(const NodeRefSegment& segment) noexcept :
+                    m_segments() {
+                    add_segment_back(segment);
+                }
+
+                explicit ProtoRing(segments_type::const_iterator sbegin, segments_type::const_iterator send) :
+                    m_segments(static_cast<size_t>(std::distance(sbegin, send))) {
+                    std::copy(sbegin, send, m_segments.begin());
+                }
+
+                bool outer() const noexcept {
+                    return m_outer;
+                }
+
+                void set_inner() noexcept {
+                    m_outer = false;
+                }
+
+                segments_type& segments() noexcept {
+                    return m_segments;
+                }
+
+                const segments_type& segments() const noexcept {
+                    return m_segments;
+                }
+
+                void remove_segments(segments_type::iterator sbegin, segments_type::iterator send) {
+                    m_segments.erase(sbegin, send);
+                }
+
+                void add_segment_front(const NodeRefSegment& segment) {
+                    m_segments.insert(m_segments.begin(), segment);
+                }
+
+                void add_segment_back(const NodeRefSegment& segment) {
+                    m_segments.push_back(segment);
+                }
+
+                const NodeRefSegment& get_segment_front() const {
+                    return m_segments.front();
+                }
+
+                NodeRefSegment& get_segment_front() {
+                    return m_segments.front();
+                }
+
+                const NodeRef& get_node_ref_front() const {
+                    return get_segment_front().first();
+                }
+
+                const NodeRefSegment& get_segment_back() const {
+                    return m_segments.back();
+                }
+
+                NodeRefSegment& get_segment_back() {
+                    return m_segments.back();
+                }
+
+                const NodeRef& get_node_ref_back() const {
+                    return get_segment_back().second();
+                }
+
+                bool closed() const {
+                    return m_segments.front().first().location() == m_segments.back().second().location();
+                }
+
+                int64_t sum() const {
+                    int64_t sum = 0;
+
+                    for (const auto& segment : m_segments) {
+                        sum += static_cast<int64_t>(segment.first().location().x()) * static_cast<int64_t>(segment.second().location().y()) -
+                               static_cast<int64_t>(segment.second().location().x()) * static_cast<int64_t>(segment.first().location().y());
+                    }
+
+                    return sum;
+                }
+
+                bool is_cw() const {
+                    return sum() <= 0;
+                }
+
+                int64_t area() const {
+                    return std::abs(sum()) / 2;
+                }
+
+                void swap_segments(ProtoRing& other) {
+                    using std::swap;
+                    swap(m_segments, other.m_segments);
+                }
+
+                void add_inner_ring(ProtoRing* ring) {
+                    m_inner.push_back(ring);
+                }
+
+                const std::vector<ProtoRing*>& inner_rings() const {
+                    return m_inner;
+                }
+
+                void print(std::ostream& out) const {
+                    out << "[";
+                    bool first = true;
+                    for (const auto& segment : m_segments) {
+                        if (first) {
+                            out << segment.first().ref();
+                        }
+                        out << ',' << segment.second().ref();
+                        first = false;
+                    }
+                    out << "]";
+                }
+
+                void reverse() {
+                    std::for_each(m_segments.begin(), m_segments.end(), [](NodeRefSegment& segment) {
+                        segment.swap_locations();
+                    });
+                    std::reverse(m_segments.begin(), m_segments.end());
+                }
+
+                /**
+                 * Merge other ring to end of this ring.
+                 */
+                void merge_ring(const ProtoRing& other, bool debug) {
+                    if (debug) {
+                        std::cerr << "        MERGE rings ";
+                        print(std::cerr);
+                        std::cerr << " to ";
+                        other.print(std::cerr);
+                        std::cerr << "\n";
+                    }
+                    m_segments.insert(m_segments.end(), other.m_segments.begin(), other.m_segments.end());
+                    if (debug) {
+                        std::cerr << "          result ring: ";
+                        print(std::cerr);
+                        std::cerr << "\n";
+                    }
+                }
+
+                void merge_ring_reverse(const ProtoRing& other, bool debug) {
+                    if (debug) {
+                        std::cerr << "        MERGE rings (reverse) ";
+                        print(std::cerr);
+                        std::cerr << " to ";
+                        other.print(std::cerr);
+                        std::cerr << "\n";
+                    }
+                    size_t n = m_segments.size();
+                    m_segments.resize(n + other.m_segments.size());
+                    std::transform(other.m_segments.rbegin(), other.m_segments.rend(), m_segments.begin() + static_cast<segments_type::difference_type>(n), [](NodeRefSegment segment) {
+                        segment.swap_locations();
+                        return segment;
+                    });
+                    if (debug) {
+                        std::cerr << "          result ring: ";
+                        print(std::cerr);
+                        std::cerr << "\n";
+                    }
+                }
+
+                const NodeRef& min_node() const {
+                    auto it = std::min_element(m_segments.begin(), m_segments.end());
+                    if (location_less()(it->first(), it->second())) {
+                        return it->first();
+                    } else {
+                        return it->second();
+                    }
+                }
+
+                bool is_in(ProtoRing* outer) {
+                    osmium::Location testpoint = segments().front().first().location();
+                    bool is_in = false;
+
+                    for (size_t i = 0, j = outer->segments().size()-1; i < outer->segments().size(); j = i++) {
+                        if (((outer->segments()[i].first().location().y() > testpoint.y()) != (outer->segments()[j].first().location().y() > testpoint.y())) &&
+                            (testpoint.x() < (outer->segments()[j].first().location().x() - outer->segments()[i].first().location().x()) * (testpoint.y() - outer->segments()[i].first().location().y()) / (outer->segments()[j].first().location().y() - outer->segments()[i].first().location().y()) + outer->segments()[i].first().location().x()) ) {
+                            is_in = !is_in;
+                        }
+                    }
+
+                    return is_in;
+                }
+
+                void get_ways(std::set<const osmium::Way*>& ways) {
+                    for (const auto& segment : m_segments) {
+                        ways.insert(segment.way());
+                    }
+                }
+
+                bool contains(const NodeRefSegment& segment) const {
+                    for (const auto& s : m_segments) {
+                        if (s == segment || (s.first() == segment.second() && s.second() == segment.first())) {
+                            return true;
+                        }
+                    }
+                    return false;
+                }
+
+            }; // class ProtoRing
+
+            template <typename TChar, typename TTraits>
+            inline std::basic_ostream<TChar, TTraits>& operator<<(std::basic_ostream<TChar, TTraits>& out, const ProtoRing& ring) {
+                ring.print(out);
+                return out;
+            }
+
+        } // namespace detail
+
+    } // namespace area
+
+} // namespace osmium
+
+#endif // OSMIUM_AREA_DETAIL_PROTO_RING_HPP

third_party/libosmium/include/osmium/area/detail/segment_list.hpp

@@ -0,0 +1,229 @@
+#ifndef OSMIUM_AREA_DETAIL_SEGMENT_LIST_HPP
+#define OSMIUM_AREA_DETAIL_SEGMENT_LIST_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <algorithm>
+#include <cassert>
+#include <iostream>
+#include <vector>
+
+#include <osmium/area/problem_reporter.hpp>
+#include <osmium/area/detail/node_ref_segment.hpp>
+#include <osmium/memory/buffer.hpp>
+#include <osmium/osm/location.hpp>
+#include <osmium/osm/node_ref.hpp>
+#include <osmium/osm/relation.hpp>
+#include <osmium/osm/way.hpp>
+
+namespace osmium {
+
+    namespace area {
+
+        namespace detail {
+
+            /**
+             * This is a helper class for the area assembler. It models
+             * a list of segments.
+             */
+            class SegmentList {
+
+                using slist_type = std::vector<NodeRefSegment>;
+
+                slist_type m_segments;
+
+                bool m_debug;
+
+            public:
+
+                explicit SegmentList(bool debug) noexcept :
+                    m_segments(),
+                    m_debug(debug) {
+                }
+
+                ~SegmentList() noexcept = default;
+
+                SegmentList(const SegmentList&) = delete;
+                SegmentList(SegmentList&&) = delete;
+
+                SegmentList& operator=(const SegmentList&) = delete;
+                SegmentList& operator=(SegmentList&&) = delete;
+
+                /// The number of segments in the list.
+                size_t size() const noexcept {
+                    return m_segments.size();
+                }
+
+                bool empty() const noexcept {
+                    return m_segments.empty();
+                }
+
+                typedef slist_type::const_iterator const_iterator;
+                typedef slist_type::iterator iterator;
+
+                iterator begin() noexcept {
+                    return m_segments.begin();
+                }
+
+                iterator end() noexcept {
+                    return m_segments.end();
+                }
+
+                const_iterator begin() const noexcept {
+                    return m_segments.begin();
+                }
+
+                const_iterator end() const noexcept {
+                    return m_segments.end();
+                }
+
+                /**
+                 * Enable or disable debug output to stderr. This is used
+                 * for debugging libosmium itself.
+                 */
+                void enable_debug_output(bool debug = true) noexcept {
+                    m_debug = debug;
+                }
+
+                /// Clear the list of segments. All segments are removed.
+                void clear() {
+                    m_segments.clear();
+                }
+
+                /// Sort the list of segments.
+                void sort() {
+                    std::sort(m_segments.begin(), m_segments.end());
+                }
+
+                /**
+                 * Extract segments from given way and add them to the list.
+                 *
+                 * Segments connecting two nodes with the same location (ie same
+                 * node or different node with same location) are removed.
+                 *
+                 * XXX should two nodes with same location be reported?
+                 */
+                void extract_segments_from_way(const osmium::Way& way, const char* role) {
+                    osmium::NodeRef last_nr;
+                    for (const osmium::NodeRef& nr : way.nodes()) {
+                        if (last_nr.location() && last_nr.location() != nr.location()) {
+                            m_segments.emplace_back(last_nr, nr, role, &way);
+                        }
+                        last_nr = nr;
+                    }
+                }
+
+                /**
+                 * Extract all segments from all ways that make up this
+                 * multipolygon relation and add them to the list.
+                 */
+                void extract_segments_from_ways(const osmium::Relation& relation, const std::vector<size_t>& members, const osmium::memory::Buffer& in_buffer) {
+                    auto member_it = relation.members().begin();
+                    for (size_t offset : members) {
+                        const osmium::Way& way = in_buffer.get<const osmium::Way>(offset);
+                        extract_segments_from_way(way, member_it->role());
+                        ++member_it;
+                    }
+                }
+
+                /**
+                 * Find duplicate segments (ie same start and end point) in the
+                 * list and remove them. This will always remove pairs of the
+                 * same segment. So if there are three, for instance, two will
+                 * be removed and one will be left.
+                 */
+                void erase_duplicate_segments() {
+                    while (true) {
+                        auto it = std::adjacent_find(m_segments.begin(), m_segments.end());
+                        if (it == m_segments.end()) {
+                            return;
+                        }
+                        if (m_debug) {
+                            std::cerr << "  erase duplicate segment: " << *it << "\n";
+                        }
+                        m_segments.erase(it, it+2);
+                    }
+                }
+
+                /**
+                 * Find intersection between segments.
+                 *
+                 * @param problem_reporter Any intersections found are
+                 *                         reported to this object.
+                 * @returns true if there are intersections.
+                 */
+                bool find_intersections(osmium::area::ProblemReporter* problem_reporter) const {
+                    if (m_segments.empty()) {
+                        return false;
+                    }
+
+                    bool found_intersections = false;
+
+                    for (auto it1 = m_segments.begin(); it1 != m_segments.end()-1; ++it1) {
+                        const NodeRefSegment& s1 = *it1;
+                        for (auto it2 = it1+1; it2 != m_segments.end(); ++it2) {
+                            const NodeRefSegment& s2 = *it2;
+
+                            assert(s1 != s2); // erase_duplicate_segments() should have made sure of that
+
+                            if (outside_x_range(s2, s1)) {
+                                break;
+                            }
+
+                            if (y_range_overlap(s1, s2)) {
+                                osmium::Location intersection = calculate_intersection(s1, s2);
+                                if (intersection) {
+                                    found_intersections = true;
+                                    if (m_debug) {
+                                        std::cerr << "  segments " << s1 << " and " << s2 << " intersecting at " << intersection << "\n";
+                                    }
+                                    if (problem_reporter) {
+                                        problem_reporter->report_intersection(s1.way()->id(), s1.first().location(), s1.second().location(), s2.way()->id(), s2.first().location(), s2.second().location(), intersection);
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+                    return found_intersections;
+                }
+
+            }; // class SegmentList
+
+        } // namespace detail
+
+    } // namespace area
+
+} // namespace osmium
+
+#endif // OSMIUM_AREA_DETAIL_SEGMENT_LIST_HPP

third_party/libosmium/include/osmium/area/multipolygon_collector.hpp

@@ -0,0 +1,201 @@
+#ifndef OSMIUM_AREA_MULTIPOLYGON_COLLECTOR_HPP
+#define OSMIUM_AREA_MULTIPOLYGON_COLLECTOR_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstring>
+#include <vector>
+
+#include <osmium/memory/buffer.hpp>
+#include <osmium/osm/item_type.hpp>
+#include <osmium/osm/location.hpp>
+#include <osmium/osm/node_ref.hpp>
+#include <osmium/osm/relation.hpp>
+#include <osmium/osm/tag.hpp>
+#include <osmium/osm/way.hpp>
+#include <osmium/relations/collector.hpp>
+#include <osmium/relations/detail/member_meta.hpp>
+
+namespace osmium {
+
+    namespace relations {
+        class RelationMeta;
+    } // namespace relations
+
+    /**
+     * @brief Code related to the building of areas (multipolygons) from relations.
+     */
+    namespace area {
+
+        /**
+         * This class collects all data needed for creating areas from
+         * relations tagged with type=multipolygon or type=boundary.
+         * Most of its functionality is derived from the parent class
+         * osmium::relations::Collector.
+         *
+         * The actual assembling of the areas is done by the assembler
+         * class given as template argument.
+         *
+         * @tparam TAssembler Multipolygon Assembler class.
+         */
+        template <typename TAssembler>
+        class MultipolygonCollector : public osmium::relations::Collector<MultipolygonCollector<TAssembler>, false, true, false> {
+
+            typedef typename osmium::relations::Collector<MultipolygonCollector<TAssembler>, false, true, false> collector_type;
+
+            typedef typename TAssembler::config_type assembler_config_type;
+            const assembler_config_type m_assembler_config;
+
+            osmium::memory::Buffer m_output_buffer;
+
+            static constexpr size_t initial_output_buffer_size = 1024 * 1024;
+            static constexpr size_t max_buffer_size_for_flush = 100 * 1024;
+
+            void flush_output_buffer() {
+                if (this->callback()) {
+                    osmium::memory::Buffer buffer(initial_output_buffer_size);
+                    using std::swap;
+                    swap(buffer, m_output_buffer);
+                    this->callback()(std::move(buffer));
+                }
+            }
+
+            void possibly_flush_output_buffer() {
+                if (m_output_buffer.committed() > max_buffer_size_for_flush) {
+                    flush_output_buffer();
+                }
+            }
+
+        public:
+
+            explicit MultipolygonCollector(const assembler_config_type& assembler_config) :
+                collector_type(),
+                m_assembler_config(assembler_config),
+                m_output_buffer(initial_output_buffer_size, osmium::memory::Buffer::auto_grow::yes) {
+            }
+
+            /**
+             * We are interested in all relations tagged with type=multipolygon
+             * or type=boundary.
+             *
+             * Overwritten from the base class.
+             */
+            bool keep_relation(const osmium::Relation& relation) const {
+                const char* type = relation.tags().get_value_by_key("type");
+
+                // ignore relations without "type" tag
+                if (!type) {
+                    return false;
+                }
+
+                if ((!strcmp(type, "multipolygon")) || (!strcmp(type, "boundary"))) {
+                    return true;
+                }
+
+                return false;
+            }
+
+            /**
+             * Overwritten from the base class.
+             */
+            bool keep_member(const osmium::relations::RelationMeta& /*relation_meta*/, const osmium::RelationMember& member) const {
+                // We are only interested in members of type way.
+                return member.type() == osmium::item_type::way;
+            }
+
+            /**
+             * This is called when a way is not in any multipolygon
+             * relation.
+             *
+             * Overwritten from the base class.
+             */
+            void way_not_in_any_relation(const osmium::Way& way) {
+                // you need at least 4 nodes to make up a polygon
+                if (way.nodes().size() <= 3) {
+                    return;
+                }
+                try {
+                    if (!way.nodes().front().location() || !way.nodes().back().location()) {
+                        throw osmium::invalid_location("invalid location");
+                    }
+                    if (way.ends_have_same_location()) {
+                        // way is closed and has enough nodes, build simple multipolygon
+                        TAssembler assembler(m_assembler_config);
+                        assembler(way, m_output_buffer);
+                        possibly_flush_output_buffer();
+                    }
+                } catch (osmium::invalid_location&) {
+                    // XXX ignore
+                }
+            }
+
+            void complete_relation(osmium::relations::RelationMeta& relation_meta) {
+                const osmium::Relation& relation = this->get_relation(relation_meta);
+                std::vector<size_t> offsets;
+                for (const auto& member : relation.members()) {
+                    if (member.ref() != 0) {
+                        offsets.push_back(this->get_offset(member.type(), member.ref()));
+                    }
+                }
+                try {
+                    TAssembler assembler(m_assembler_config);
+                    assembler(relation, offsets, this->members_buffer(), m_output_buffer);
+                    possibly_flush_output_buffer();
+                } catch (osmium::invalid_location&) {
+                    // XXX ignore
+                }
+            }
+
+            void flush() {
+                flush_output_buffer();
+            }
+
+            osmium::memory::Buffer read() {
+                osmium::memory::Buffer buffer(initial_output_buffer_size, osmium::memory::Buffer::auto_grow::yes);
+
+                using std::swap;
+                swap(buffer, m_output_buffer);
+
+                return buffer;
+            }
+
+        }; // class MultipolygonCollector
+
+    } // namespace area
+
+} // namespace osmium
+
+#endif // OSMIUM_AREA_MULTIPOLYGON_COLLECTOR_HPP

third_party/libosmium/include/osmium/area/problem_reporter.hpp

@@ -0,0 +1,149 @@
+#ifndef OSMIUM_AREA_PROBLEM_REPORTER_HPP
+#define OSMIUM_AREA_PROBLEM_REPORTER_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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/osm/item_type.hpp>
+#include <osmium/osm/location.hpp>
+#include <osmium/osm/types.hpp>
+
+namespace osmium {
+
+    namespace area {
+
+        /**
+         * When assembling a multipolygon/area from a multipolygon relation
+         * or a closed way several problems can be detected. This includes
+         * intersections between lines, wrong role attributes on relation
+         * members etc. These problems are reported by the area::Assembler
+         * class to the ProblemReporter class or one of its child classes.
+         *
+         * This is the parent class which does nothing with the reports.
+         * Child classes are expected to implement different ways of
+         * reporting the problems.
+         */
+        class ProblemReporter {
+
+        protected:
+
+            // Type of object we are currently working on
+            osmium::item_type m_object_type;
+
+            // ID of the relation/way we are currently working on
+            osmium::object_id_type m_object_id;
+
+        public:
+
+            ProblemReporter() = default;
+
+            virtual ~ProblemReporter() = default;
+
+            /**
+             * Set the object the next problem reports will be on.
+             *
+             * @param object_type The type of the object.
+             * @param object_id The ID of the object.
+             */
+            void set_object(osmium::item_type object_type, osmium::object_id_type object_id) noexcept {
+                m_object_type = object_type;
+                m_object_id = object_id;
+            }
+
+// Disable "unused-parameter" warning, so that the compiler will not complain.
+// We can't remove the parameter names, because then doxygen will complain.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+
+            /**
+             * Report a duplicate node, ie. two nodes with the same location.
+             *
+             * @param node_id1       ID of the first node.
+             * @param node_id2       ID of the second node.
+             * @param location       Location of both nodes.
+             */
+            virtual void report_duplicate_node(osmium::object_id_type node_id1, osmium::object_id_type node_id2, osmium::Location location) {
+            }
+
+            /**
+             * Report an intersection between two segments.
+             *
+             * @param way1_id        ID of the first involved way.
+             * @param way1_seg_start Location where the segment of the first way with the intersection starts
+             * @param way1_seg_end   Location where the segment of the first way with the intersection ends
+             * @param way2_id        ID of the second involved way.
+             * @param way2_seg_start Location where the segment of the second way with the intersection starts
+             * @param way2_seg_end   Location where the segment of the second way with the intersection ends
+             * @param intersection   Location of the intersection. This might be slightly off the correct location due to rounding.
+             */
+            virtual 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) {
+            }
+
+            /**
+             * Report an open ring.
+             *
+             * @param end1           Location of the first open end.
+             * @param end2           Location of the second open end.
+             */
+            virtual void report_ring_not_closed(osmium::Location end1, osmium::Location end2) {
+            }
+
+            /**
+             * Report a segment that should have role "outer", but has a different role.
+             *
+             * @param way_id         ID of the way this segment is in.
+             * @param seg_start      Start of the segment with the wrong role.
+             * @param seg_end        End of the segment with the wrong role.
+             */
+            virtual void report_role_should_be_outer(osmium::object_id_type way_id, osmium::Location seg_start, osmium::Location seg_end) {
+            }
+
+            /**
+             * Report a segment that should have role "inner", but has a different role.
+             *
+             * @param way_id         ID of the way this segment is in.
+             * @param seg_start      Start of the segment with the wrong role.
+             * @param seg_end        End of the segment with the wrong role.
+             */
+            virtual void report_role_should_be_inner(osmium::object_id_type way_id, osmium::Location seg_start, osmium::Location seg_end) {
+            }
+
+#pragma GCC diagnostic pop
+
+        }; // class ProblemReporter
+
+    } // namespace area
+
+} // namespace osmium
+
+#endif // OSMIUM_AREA_PROBLEM_REPORTER_HPP

third_party/libosmium/include/osmium/area/problem_reporter_exception.hpp

@@ -0,0 +1,96 @@
+#ifndef OSMIUM_AREA_PROBLEM_REPORTER_EXCEPTION_HPP
+#define OSMIUM_AREA_PROBLEM_REPORTER_EXCEPTION_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <sstream>
+#include <stdexcept>
+
+#include <osmium/area/problem_reporter_stream.hpp>
+#include <osmium/osm/location.hpp>
+#include <osmium/osm/types.hpp>
+
+namespace osmium {
+
+    namespace area {
+
+        class ProblemReporterException : public ProblemReporterStream {
+
+            std::stringstream m_sstream;
+
+        public:
+
+            ProblemReporterException() :
+                ProblemReporterStream(m_sstream) {
+            }
+
+            ~ProblemReporterException() override = default;
+
+            void report_duplicate_node(osmium::object_id_type node_id1, osmium::object_id_type node_id2, osmium::Location location) override {
+                m_sstream.str();
+                ProblemReporterStream::report_duplicate_node(node_id1, node_id2, location);
+                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,
+                                     osmium::object_id_type way2_id, osmium::Location way2_seg_start, osmium::Location way2_seg_end, osmium::Location intersection) override {
+                m_sstream.str();
+                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());
+            }
+
+            void report_ring_not_closed(osmium::Location end1, osmium::Location end2) override {
+                m_sstream.str();
+                ProblemReporterStream::report_ring_not_closed(end1, end2);
+                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 {
+                m_sstream.str();
+                ProblemReporterStream::report_role_should_be_outer(way_id, seg_start, seg_end);
+                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 {
+                m_sstream.str();
+                ProblemReporterStream::report_role_should_be_inner(way_id, seg_start, seg_end);
+                throw std::runtime_error(m_sstream.str());
+            }
+
+        }; // class ProblemReporterException
+
+    } // namespace area
+
+} // namespace osmium
+
+#endif // OSMIUM_AREA_PROBLEM_REPORTER_EXCEPTION_HPP

third_party/libosmium/include/osmium/area/problem_reporter_ogr.hpp

@@ -0,0 +1,139 @@
+#ifndef OSMIUM_AREA_PROBLEM_REPORTER_OGR_HPP
+#define OSMIUM_AREA_PROBLEM_REPORTER_OGR_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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.
+
+*/
+
+/**
+ * @file
+ *
+ * This file contains code for reporting problems through OGR when
+ * assembling multipolygons.
+ *
+ * @attention If you include this file, you'll need to link with `libgdal`.
+ */
+
+#include <memory>
+
+#include <gdalcpp.hpp>
+
+#include <osmium/area/problem_reporter.hpp>
+#include <osmium/geom/factory.hpp>
+#include <osmium/geom/ogr.hpp>
+#include <osmium/osm/location.hpp>
+#include <osmium/osm/types.hpp>
+
+namespace osmium {
+
+    namespace area {
+
+        /**
+         * Report problems when assembling areas by adding them to
+         * layers in an OGR datasource.
+         */
+        class ProblemReporterOGR : public ProblemReporter {
+
+            osmium::geom::OGRFactory<> m_ogr_factory;
+
+            gdalcpp::Layer m_layer_perror;
+            gdalcpp::Layer m_layer_lerror;
+
+            void write_point(const char* problem_type, osmium::object_id_type id1, osmium::object_id_type id2, osmium::Location location) {
+                gdalcpp::Feature feature(m_layer_perror, m_ogr_factory.create_point(location));
+                feature.set_field("id1", static_cast<double>(id1));
+                feature.set_field("id2", static_cast<double>(id2));
+                feature.set_field("problem_type", problem_type);
+                feature.add_to_layer();
+            }
+
+            void write_line(const char* problem_type, osmium::object_id_type id1, osmium::object_id_type id2, osmium::Location loc1, osmium::Location loc2) {
+                std::unique_ptr<OGRPoint> ogr_point1 = m_ogr_factory.create_point(loc1);
+                std::unique_ptr<OGRPoint> ogr_point2 = m_ogr_factory.create_point(loc2);
+                std::unique_ptr<OGRLineString> ogr_linestring = std::unique_ptr<OGRLineString>(new OGRLineString());
+                ogr_linestring->addPoint(ogr_point1.get());
+                ogr_linestring->addPoint(ogr_point2.get());
+
+                gdalcpp::Feature feature(m_layer_lerror, std::move(ogr_linestring));
+                feature.set_field("id1", static_cast<double>(id1));
+                feature.set_field("id2", static_cast<double>(id2));
+                feature.set_field("problem_type", problem_type);
+                feature.add_to_layer();
+            }
+
+        public:
+
+            explicit ProblemReporterOGR(gdalcpp::Dataset& dataset) :
+                m_layer_perror(dataset, "perrors", wkbPoint),
+                m_layer_lerror(dataset, "lerrors", wkbLineString) {
+
+                m_layer_perror.add_field("id1", OFTReal, 10);
+                m_layer_perror.add_field("id2", OFTReal, 10);
+                m_layer_perror.add_field("problem_type", OFTString, 30);
+
+                m_layer_lerror.add_field("id1", OFTReal, 10);
+                m_layer_lerror.add_field("id2", OFTReal, 10);
+                m_layer_lerror.add_field("problem_type", OFTString, 30);
+            }
+
+            ~ProblemReporterOGR() override = default;
+
+            void report_duplicate_node(osmium::object_id_type node_id1, osmium::object_id_type node_id2, osmium::Location location) override {
+                write_point("duplicate_node", node_id1, node_id2, location);
+            }
+
+            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 {
+                write_point("intersection", m_object_id, 0, intersection);
+                write_line("intersection", m_object_id, way1_id, way1_seg_start, way1_seg_end);
+                write_line("intersection", m_object_id, way2_id, way2_seg_start, way2_seg_end);
+            }
+
+            void report_ring_not_closed(osmium::Location end1, osmium::Location end2) override {
+                write_point("ring_not_closed", m_object_id, 0, end1);
+                write_point("ring_not_closed", m_object_id, 0, end2);
+            }
+
+            void report_role_should_be_outer(osmium::object_id_type way_id, osmium::Location seg_start, osmium::Location seg_end) override {
+                write_line("role_should_be_outer", m_object_id, way_id, seg_start, seg_end);
+            }
+
+            void report_role_should_be_inner(osmium::object_id_type way_id, osmium::Location seg_start, osmium::Location seg_end) override {
+                write_line("role_should_be_inner", m_object_id, way_id, seg_start, seg_end);
+            }
+
+        }; // class ProblemReporterOGR
+
+    } // namespace area
+
+} // namespace osmium
+
+#endif // OSMIUM_AREA_PROBLEM_REPORTER_OGR_HPP

third_party/libosmium/include/osmium/area/problem_reporter_stream.hpp

@@ -0,0 +1,96 @@
+#ifndef OSMIUM_AREA_PROBLEM_REPORTER_STREAM_HPP
+#define OSMIUM_AREA_PROBLEM_REPORTER_STREAM_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <ostream>
+
+#include <osmium/area/problem_reporter.hpp>
+#include <osmium/osm/item_type.hpp>
+#include <osmium/osm/location.hpp>
+#include <osmium/osm/types.hpp>
+
+namespace osmium {
+
+    namespace area {
+
+        class ProblemReporterStream : public ProblemReporter {
+
+            std::ostream* m_out;
+
+        public:
+
+            explicit ProblemReporterStream(std::ostream& out) :
+                m_out(&out) {
+            }
+
+            ~ProblemReporterStream() override = default;
+
+            void header(const char* msg) {
+                *m_out << "DATA PROBLEM: " << msg << " on " << item_type_to_char(m_object_type) << m_object_id << ": ";
+            }
+
+            void report_duplicate_node(osmium::object_id_type node_id1, osmium::object_id_type node_id2, osmium::Location location) override {
+                header("duplicate node");
+                *m_out << "node_id1=" << node_id1 << " node_id2=" << node_id2 << " location=" << location << "\n";
+            }
+
+            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 {
+                header("intersection");
+                *m_out << "way1_id=" << way1_id << " way1_seg_start=" << way1_seg_start << " way1_seg_end=" << way1_seg_end
+                       << " way2_id=" << way2_id << " way2_seg_start=" << way2_seg_start << " way2_seg_end=" << way2_seg_end << " intersection=" << intersection << "\n";
+            }
+
+            void report_ring_not_closed(osmium::Location end1, osmium::Location end2) override {
+                header("ring not closed");
+                *m_out << "end1=" << end1 << " end2=" << end2 << "\n";
+            }
+
+            void report_role_should_be_outer(osmium::object_id_type way_id, osmium::Location seg_start, osmium::Location seg_end) override {
+                header("role should be outer");
+                *m_out << "way_id=" << way_id << " seg_start=" << seg_start << " seg_end=" << seg_end << "\n";
+            }
+
+            void report_role_should_be_inner(osmium::object_id_type way_id, osmium::Location seg_start, osmium::Location seg_end) override {
+                header("role should be inner");
+                *m_out << "way_id=" << way_id << " seg_start=" << seg_start << " seg_end=" << seg_end << "\n";
+            }
+
+        }; // class ProblemReporterStream
+
+    } // namespace area
+
+} // namespace osmium
+
+#endif // OSMIUM_AREA_PROBLEM_REPORTER_STREAM_HPP

third_party/libosmium/include/osmium/builder/attr.hpp

@@ -0,0 +1,877 @@
+#ifndef OSMIUM_BUILDER_ATTR_HPP
+#define OSMIUM_BUILDER_ATTR_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <cstddef>
+#include <cstdint>
+#include <ctime>
+#include <initializer_list>
+#include <iterator>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include <osmium/builder/builder.hpp>
+#include <osmium/builder/osm_object_builder.hpp>
+#include <osmium/memory/buffer.hpp>
+#include <osmium/osm/types.hpp>
+#include <osmium/osm.hpp>
+
+namespace osmium {
+
+    namespace builder {
+
+        namespace detail {
+
+#ifdef _MSC_VER
+            // workaround for bug in MSVC
+
+            template <typename THandler, typename... TTypes>
+            struct is_handled_by;
+
+            template <typename THandler>
+            struct is_handled_by<THandler> {
+                static constexpr bool value = false;
+            };
+
+            template <typename THandler, typename T, typename... TRest>
+            struct is_handled_by<THandler, T, TRest...> {
+                static constexpr bool value = std::is_base_of<typename T::handler, THandler>::value ||
+                                              is_handled_by<THandler, TRest...>::value;
+            };
+
+            template <typename THandler, typename... TTypes>
+            struct are_all_handled_by;
+
+            template <typename THandler, typename T>
+            struct are_all_handled_by<THandler, T> {
+                static constexpr bool value = std::is_base_of<typename T::handler, THandler>::value;
+            };
+
+            template <typename THandler, typename T, typename... TRest>
+            struct are_all_handled_by<THandler, T, TRest...> {
+                static constexpr bool value = std::is_base_of<typename T::handler, THandler>::value &&
+                                              are_all_handled_by<THandler, TRest...>::value;
+            };
+#else
+            // True if Predicate matches for none of the types Ts
+            template <template<typename> class Predicate, typename... Ts>
+            struct static_none_of : std::is_same<std::tuple<std::false_type, typename Predicate<Ts>::type...>,
+                                                 std::tuple<typename Predicate<Ts>::type..., std::false_type>>
+            {};
+
+            // True if Predicate matches for all of the types Ts
+            template <template<typename> class Predicate, typename... Ts>
+            struct static_all_of : std::is_same<std::tuple<std::true_type, typename Predicate<Ts>::type...>,
+                                                std::tuple<typename Predicate<Ts>::type..., std::true_type>>
+            {};
+
+            // True if THandler is derived from the handler for at least one of the types in TTypes
+            template <typename THandler, typename... TTypes>
+            struct is_handled_by {
+                template <typename T>
+                using HasHandler = std::is_base_of<typename T::handler, THandler>;
+
+                static constexpr bool value = !static_none_of<HasHandler, TTypes...>::value;
+            };
+
+            // True if THandler is derived from the handlers of all the types in TTypes
+            template <typename THandler, typename... TTypes>
+            struct are_all_handled_by {
+                template <typename T>
+                using HasHandler = std::is_base_of<typename T::handler, THandler>;
+
+                static constexpr bool value = static_all_of<HasHandler, TTypes...>::value;
+            };
+#endif
+
+
+            // Wraps any type, so that we can derive from it
+            template <typename TType>
+            struct type_wrapper {
+
+                using type = TType;
+
+                TType value;
+
+                constexpr explicit type_wrapper(const TType& v) :
+                    value(v) {
+                }
+
+            }; // struct type_wrapper
+
+            // Small wrapper for begin/end iterator
+            template <typename TType>
+            struct iterator_wrapper {
+
+                using type = TType;
+
+                TType first;
+                TType last;
+
+                constexpr iterator_wrapper(TType begin, TType end) :
+                    first(begin),
+                    last(end) {}
+
+                constexpr TType begin() const {
+                    return first;
+                }
+
+                constexpr TType end() const {
+                    return last;
+                }
+
+            }; // struct iterator_wrapper
+
+
+            struct entity_handler {};
+            struct object_handler;
+            struct node_handler;
+            struct tags_handler;
+            struct nodes_handler;
+            struct members_handler;
+            struct changeset_handler;
+            struct discussion_handler;
+            struct ring_handler;
+
+        } // namespace detail
+
+#define OSMIUM_ATTRIBUTE(_handler, _name, _type) \
+    struct _name : public osmium::builder::detail::type_wrapper<_type> { \
+        using handler = osmium::builder::detail::_handler;
+
+#define OSMIUM_ATTRIBUTE_WITH_CONSTRUCTOR(_handler, _name, _type) \
+    OSMIUM_ATTRIBUTE(_handler, _name, _type) \
+        constexpr explicit _name(std::add_const<_type>::type& value) : \
+            type_wrapper(value) {} \
+    }
+
+#define OSMIUM_ATTRIBUTE_ITER(_handler, _name) \
+    template <typename TIterator> \
+    struct _name : public osmium::builder::detail::iterator_wrapper<TIterator> { \
+        using handler = osmium::builder::detail::_handler; \
+        constexpr _name(TIterator first, TIterator last) : \
+            osmium::builder::detail::iterator_wrapper<TIterator>(first, last) {} \
+    }
+
+        namespace attr {
+
+            OSMIUM_ATTRIBUTE_WITH_CONSTRUCTOR(object_handler, _id, osmium::object_id_type);
+            OSMIUM_ATTRIBUTE_WITH_CONSTRUCTOR(object_handler, _version, osmium::object_version_type);
+            OSMIUM_ATTRIBUTE_WITH_CONSTRUCTOR(entity_handler, _uid, osmium::user_id_type);
+            OSMIUM_ATTRIBUTE_WITH_CONSTRUCTOR(entity_handler, _cid, osmium::changeset_id_type);
+
+            OSMIUM_ATTRIBUTE(object_handler, _deleted, bool)
+                constexpr explicit _deleted(bool value = true) noexcept :
+                    type_wrapper(value) {}
+            };
+
+            OSMIUM_ATTRIBUTE(object_handler, _visible, bool)
+                constexpr explicit _visible(bool value = true) noexcept :
+                    type_wrapper(value) {}
+            };
+
+            OSMIUM_ATTRIBUTE(object_handler, _timestamp, osmium::Timestamp)
+                constexpr explicit _timestamp(const osmium::Timestamp& value) noexcept :
+                    type_wrapper(value) {}
+                constexpr explicit _timestamp(time_t value) noexcept :
+                    type_wrapper(osmium::Timestamp{value}) {}
+                constexpr explicit _timestamp(uint32_t value) noexcept :
+                    type_wrapper(osmium::Timestamp{value}) {}
+                explicit _timestamp(const char* value) :
+                    type_wrapper(osmium::Timestamp{value}) {}
+                explicit _timestamp(const std::string& value) :
+                    type_wrapper(osmium::Timestamp{value}) {}
+            };
+
+            OSMIUM_ATTRIBUTE(node_handler, _location, osmium::Location)
+                constexpr explicit _location(const osmium::Location& value) noexcept :
+                    type_wrapper(value) {}
+                explicit _location(double lat, double lon) :
+                    type_wrapper(osmium::Location{lat, lon}) {}
+            };
+
+            OSMIUM_ATTRIBUTE(entity_handler, _user, const char*)
+                constexpr explicit _user(const char* val) noexcept :
+                    type_wrapper(val) {}
+                explicit _user(const std::string& val) noexcept :
+                    type_wrapper(val.c_str()) {}
+            };
+
+            using pair_of_cstrings = std::pair<const char* const, const char* const>;
+            using pair_of_strings = std::pair<const std::string&, const std::string&>;
+
+            class member_type {
+
+                osmium::item_type      m_type;
+                osmium::object_id_type m_ref;
+                const char*            m_role;
+
+            public:
+
+                constexpr member_type(osmium::item_type type, osmium::object_id_type ref, const char* role = "") noexcept :
+                    m_type(type),
+                    m_ref(ref),
+                    m_role(role) {
+                }
+
+                constexpr osmium::item_type type() const noexcept {
+                    return m_type;
+                }
+
+                constexpr osmium::object_id_type ref() const noexcept {
+                    return m_ref;
+                }
+
+                constexpr const char* role() const noexcept {
+                    return m_role;
+                }
+
+            }; // class member_type
+
+            class comment_type {
+
+                osmium::Timestamp    m_date;
+                osmium::user_id_type m_uid;
+                const char*          m_user;
+                const char*          m_text;
+
+            public:
+
+                constexpr comment_type(osmium::Timestamp date, osmium::user_id_type uid, const char* user, const char* text) noexcept :
+                    m_date(date),
+                    m_uid(uid),
+                    m_user(user),
+                    m_text(text) {
+                }
+
+                constexpr osmium::Timestamp date() const noexcept {
+                    return m_date;
+                }
+
+                constexpr osmium::user_id_type uid() const noexcept {
+                    return m_uid;
+                }
+
+                constexpr const char* user() const noexcept {
+                    return m_user;
+                }
+
+                constexpr const char* text() const noexcept {
+                    return m_text;
+                }
+
+            }; // class comment_type
+
+            namespace detail {
+
+                OSMIUM_ATTRIBUTE_ITER(tags_handler, tags_from_iterator_pair);
+
+                OSMIUM_ATTRIBUTE_ITER(nodes_handler, nodes_from_iterator_pair);
+
+                OSMIUM_ATTRIBUTE_ITER(members_handler, members_from_iterator_pair);
+
+                OSMIUM_ATTRIBUTE_ITER(discussion_handler, comments_from_iterator_pair);
+
+                OSMIUM_ATTRIBUTE_ITER(ring_handler, outer_ring_from_iterator_pair);
+                OSMIUM_ATTRIBUTE_ITER(ring_handler, inner_ring_from_iterator_pair);
+
+            } // namespace detail
+
+            OSMIUM_ATTRIBUTE(tags_handler, _tag, pair_of_cstrings)
+                explicit _tag(const pair_of_cstrings& value) noexcept :
+                    type_wrapper(value) {}
+                explicit _tag(const std::pair<const char* const, const char*>& value) :
+                    type_wrapper(pair_of_cstrings{value.first, value.second}) {}
+                explicit _tag(const std::pair<const char*, const char* const>& value) :
+                    type_wrapper(pair_of_cstrings{value.first, value.second}) {}
+                explicit _tag(const std::pair<const char*, const char*>& value) :
+                    type_wrapper(pair_of_cstrings{value.first, value.second}) {}
+                explicit _tag(const pair_of_strings& value) :
+                    type_wrapper(std::make_pair(value.first.c_str(), value.second.c_str())) {}
+                explicit _tag(const char* key, const char* val) :
+                    type_wrapper(std::make_pair(key, val)) {}
+                explicit _tag(const std::string& key, const std::string& val) :
+                    type_wrapper(std::make_pair(key.c_str(), val.c_str())) {}
+            };
+
+            template <typename TTagIterator>
+            inline constexpr detail::tags_from_iterator_pair<TTagIterator> _tags(TTagIterator first, TTagIterator last) {
+                return detail::tags_from_iterator_pair<TTagIterator>(first, last);
+            }
+
+            template <typename TContainer>
+            inline detail::tags_from_iterator_pair<typename TContainer::const_iterator> _tags(const TContainer& container) {
+                return detail::tags_from_iterator_pair<typename TContainer::const_iterator>(std::begin(container), std::end(container));
+            }
+
+            using tag_ilist = std::initializer_list<std::pair<const char*, const char*>>;
+            inline detail::tags_from_iterator_pair<tag_ilist::const_iterator> _tags(const tag_ilist& container) {
+                return detail::tags_from_iterator_pair<tag_ilist::const_iterator>(std::begin(container), std::end(container));
+            }
+
+
+
+            OSMIUM_ATTRIBUTE(nodes_handler, _node, osmium::NodeRef)
+                constexpr explicit _node(osmium::object_id_type value) noexcept :
+                    type_wrapper(NodeRef{value}) {}
+                constexpr explicit _node(const NodeRef& value) noexcept :
+                    type_wrapper(value) {}
+            };
+
+            template <typename TIdIterator>
+            inline constexpr detail::nodes_from_iterator_pair<TIdIterator> _nodes(TIdIterator first, TIdIterator last) {
+                return detail::nodes_from_iterator_pair<TIdIterator>(first, last);
+            }
+
+            template <typename TContainer>
+            inline detail::nodes_from_iterator_pair<typename TContainer::const_iterator> _nodes(const TContainer& container) {
+                return detail::nodes_from_iterator_pair<typename TContainer::const_iterator>(std::begin(container), std::end(container));
+            }
+
+            using object_id_ilist = std::initializer_list<osmium::object_id_type>;
+            inline detail::nodes_from_iterator_pair<object_id_ilist::const_iterator> _nodes(const object_id_ilist& container) {
+                return detail::nodes_from_iterator_pair<object_id_ilist::const_iterator>(std::begin(container), std::end(container));
+            }
+
+            using node_ref_ilist = std::initializer_list<osmium::NodeRef>;
+            inline detail::nodes_from_iterator_pair<node_ref_ilist::const_iterator> _nodes(const node_ref_ilist& container) {
+                return detail::nodes_from_iterator_pair<node_ref_ilist::const_iterator>(std::begin(container), std::end(container));
+            }
+
+
+            OSMIUM_ATTRIBUTE(members_handler, _member, member_type)
+                constexpr explicit _member(const member_type& value) noexcept :
+                    type_wrapper(value) {}
+                constexpr explicit _member(osmium::item_type type, osmium::object_id_type id) noexcept :
+                    type_wrapper({type, id}) {}
+                constexpr explicit _member(osmium::item_type type, osmium::object_id_type id, const char* role) noexcept :
+                    type_wrapper({type, id, role}) {}
+                explicit _member(osmium::item_type type, osmium::object_id_type id, const std::string& role) noexcept :
+                    type_wrapper({type, id, role.c_str()}) {}
+                explicit _member(const osmium::RelationMember& member) noexcept :
+                    type_wrapper({member.type(), member.ref(), member.role()}) {}
+            };
+
+            template <typename TMemberIterator>
+            inline constexpr detail::members_from_iterator_pair<TMemberIterator> _members(TMemberIterator first, TMemberIterator last) {
+                return detail::members_from_iterator_pair<TMemberIterator>(first, last);
+            }
+
+            template <typename TContainer>
+            inline detail::members_from_iterator_pair<typename TContainer::const_iterator> _members(const TContainer& container) {
+                return detail::members_from_iterator_pair<typename TContainer::const_iterator>(std::begin(container), std::end(container));
+            }
+
+            using member_ilist = std::initializer_list<member_type>;
+            inline detail::members_from_iterator_pair<member_ilist::const_iterator> _members(const member_ilist& container) {
+                return detail::members_from_iterator_pair<member_ilist::const_iterator>(std::begin(container), std::end(container));
+            }
+
+
+            OSMIUM_ATTRIBUTE_WITH_CONSTRUCTOR(changeset_handler, _num_changes, osmium::num_changes_type);
+            OSMIUM_ATTRIBUTE_WITH_CONSTRUCTOR(changeset_handler, _num_comments, osmium::num_comments_type);
+            OSMIUM_ATTRIBUTE_WITH_CONSTRUCTOR(changeset_handler, _created_at, osmium::Timestamp);
+            OSMIUM_ATTRIBUTE_WITH_CONSTRUCTOR(changeset_handler, _closed_at, osmium::Timestamp);
+
+            OSMIUM_ATTRIBUTE(discussion_handler, _comment, comment_type)
+                constexpr explicit _comment(const comment_type& value) noexcept :
+                    type_wrapper(value) {}
+                explicit _comment(const osmium::ChangesetComment& comment) noexcept :
+                    type_wrapper({comment.date(), comment.uid(), comment.user(), comment.text()}) {}
+            };
+
+            template <typename TCommentIterator>
+            inline constexpr detail::comments_from_iterator_pair<TCommentIterator> _comments(TCommentIterator first, TCommentIterator last) {
+                return detail::comments_from_iterator_pair<TCommentIterator>(first, last);
+            }
+
+            template <typename TContainer>
+            inline detail::comments_from_iterator_pair<typename TContainer::const_iterator> _comments(const TContainer& container) {
+                return detail::comments_from_iterator_pair<typename TContainer::const_iterator>(std::begin(container), std::end(container));
+            }
+
+            using comment_ilist = std::initializer_list<comment_type>;
+            inline detail::comments_from_iterator_pair<comment_ilist::const_iterator> _comments(const comment_ilist& container) {
+                return detail::comments_from_iterator_pair<comment_ilist::const_iterator>(std::begin(container), std::end(container));
+            }
+
+
+            template <typename TIdIterator>
+            inline constexpr detail::outer_ring_from_iterator_pair<TIdIterator> _outer_ring(TIdIterator first, TIdIterator last) {
+                return detail::outer_ring_from_iterator_pair<TIdIterator>(first, last);
+            }
+
+            template <typename TContainer>
+            inline detail::outer_ring_from_iterator_pair<typename TContainer::const_iterator> _outer_ring(const TContainer& container) {
+                return detail::outer_ring_from_iterator_pair<typename TContainer::const_iterator>(std::begin(container), std::end(container));
+            }
+
+            using object_id_ilist = std::initializer_list<osmium::object_id_type>;
+            inline detail::outer_ring_from_iterator_pair<object_id_ilist::const_iterator> _outer_ring(const object_id_ilist& container) {
+                return detail::outer_ring_from_iterator_pair<object_id_ilist::const_iterator>(std::begin(container), std::end(container));
+            }
+
+            using node_ref_ilist = std::initializer_list<osmium::NodeRef>;
+            inline detail::outer_ring_from_iterator_pair<node_ref_ilist::const_iterator> _outer_ring(const node_ref_ilist& container) {
+                return detail::outer_ring_from_iterator_pair<node_ref_ilist::const_iterator>(std::begin(container), std::end(container));
+            }
+
+            template <typename TIdIterator>
+            inline constexpr detail::inner_ring_from_iterator_pair<TIdIterator> _inner_ring(TIdIterator first, TIdIterator last) {
+                return detail::inner_ring_from_iterator_pair<TIdIterator>(first, last);
+            }
+
+            template <typename TContainer>
+            inline detail::inner_ring_from_iterator_pair<typename TContainer::const_iterator> _inner_ring(const TContainer& container) {
+                return detail::inner_ring_from_iterator_pair<typename TContainer::const_iterator>(std::begin(container), std::end(container));
+            }
+
+            using object_id_ilist = std::initializer_list<osmium::object_id_type>;
+            inline detail::inner_ring_from_iterator_pair<object_id_ilist::const_iterator> _inner_ring(const object_id_ilist& container) {
+                return detail::inner_ring_from_iterator_pair<object_id_ilist::const_iterator>(std::begin(container), std::end(container));
+            }
+
+            using node_ref_ilist = std::initializer_list<osmium::NodeRef>;
+            inline detail::inner_ring_from_iterator_pair<node_ref_ilist::const_iterator> _inner_ring(const node_ref_ilist& container) {
+                return detail::inner_ring_from_iterator_pair<node_ref_ilist::const_iterator>(std::begin(container), std::end(container));
+            }
+
+
+        } // namespace attr
+
+#undef OSMIUM_ATTRIBUTE_ITER
+#undef OSMIUM_ATTRIBUTE_WITH_CONSTRUCTOR
+#undef OSMIUM_ATTRIBUTE
+
+        namespace detail {
+
+            struct changeset_handler : public entity_handler {
+
+                template <typename TDummy>
+                static void set_value(osmium::Changeset&, const TDummy&) noexcept {
+                }
+
+                static void set_value(osmium::Changeset& changeset, attr::_cid id) noexcept {
+                    changeset.set_id(id.value);
+                }
+
+                static void set_value(osmium::Changeset& changeset, attr::_num_changes num_changes) noexcept {
+                    changeset.set_num_changes(num_changes.value);
+                }
+
+                static void set_value(osmium::Changeset& changeset, attr::_num_comments num_comments) noexcept {
+                    changeset.set_num_comments(num_comments.value);
+                }
+
+                static void set_value(osmium::Changeset& changeset, attr::_created_at created_at) noexcept {
+                    changeset.set_created_at(created_at.value);
+                }
+
+                static void set_value(osmium::Changeset& changeset, attr::_closed_at closed_at) noexcept {
+                    changeset.set_closed_at(closed_at.value);
+                }
+
+                static void set_value(osmium::Changeset& changeset, attr::_uid uid) noexcept {
+                    changeset.set_uid(uid.value);
+                }
+
+            };
+
+            struct object_handler : public entity_handler {
+
+                template <typename TDummy>
+                static void set_value(osmium::OSMObject&, const TDummy&) noexcept {
+                }
+
+                static void set_value(osmium::OSMObject& object, attr::_id id) noexcept {
+                    object.set_id(id.value);
+                }
+
+                static void set_value(osmium::OSMObject& object, attr::_version version) noexcept {
+                    object.set_version(version.value);
+                }
+
+                static void set_value(osmium::OSMObject& object, attr::_visible visible) noexcept {
+                    object.set_visible(visible.value);
+                }
+
+                static void set_value(osmium::OSMObject& object, attr::_deleted deleted) noexcept {
+                    object.set_deleted(deleted.value);
+                }
+
+                static void set_value(osmium::OSMObject& object, attr::_timestamp timestamp) noexcept {
+                    object.set_timestamp(timestamp.value);
+                }
+
+                static void set_value(osmium::OSMObject& object, attr::_cid changeset) noexcept {
+                    object.set_changeset(changeset.value);
+                }
+
+                static void set_value(osmium::OSMObject& object, attr::_uid uid) noexcept {
+                    object.set_uid(uid.value);
+                }
+
+            }; // object_handler
+
+            struct node_handler : public object_handler {
+
+                using object_handler::set_value;
+
+                static void set_value(osmium::Node& node, attr::_location location) noexcept {
+                    node.set_location(location.value);
+                }
+
+            }; // node_handler
+
+            template <typename THandler, typename TBuilder, typename... TArgs>
+            inline void add_basic(TBuilder& builder, const TArgs&... args) noexcept {
+                (void)std::initializer_list<int>{
+                    (THandler::set_value(builder.object(), args), 0)...
+                };
+            }
+
+            // ==============================================================
+
+            template <typename... TArgs>
+            inline constexpr const char* get_user(const attr::_user& user, const TArgs&...) noexcept {
+                return user.value;
+            }
+
+            inline constexpr const char* get_user() noexcept {
+                return "";
+            }
+
+            template <typename TFirst, typename... TRest>
+            inline constexpr typename std::enable_if<!std::is_same<attr::_user, TFirst>::value, const char*>::type
+            get_user(const TFirst&, const TRest&... args) noexcept {
+                return get_user(args...);
+            }
+
+            template <typename TBuilder, typename... TArgs>
+            inline void add_user(TBuilder& builder, const TArgs&... args) {
+                builder.add_user(get_user(args...));
+            }
+
+            // ==============================================================
+
+            struct tags_handler {
+
+                template <typename TDummy>
+                static void set_value(TagListBuilder&, const TDummy&) noexcept {
+                }
+
+                static void set_value(TagListBuilder& builder, const attr::_tag& tag) {
+                    builder.add_tag(tag.value);
+                }
+
+                template <typename TIterator>
+                static void set_value(TagListBuilder& builder, const attr::detail::tags_from_iterator_pair<TIterator>& tags) {
+                    for (const auto& tag : tags) {
+                        builder.add_tag(tag);
+                    }
+                }
+
+            }; // struct tags_handler
+
+            struct nodes_handler {
+
+                template <typename TDummy>
+                static void set_value(WayNodeListBuilder&, const TDummy&) noexcept {
+                }
+
+                static void set_value(WayNodeListBuilder& builder, const attr::_node& node_ref) {
+                    builder.add_node_ref(node_ref.value);
+                }
+
+                template <typename TIterator>
+                static void set_value(WayNodeListBuilder& builder, const attr::detail::nodes_from_iterator_pair<TIterator>& nodes) {
+                    for (const auto& ref : nodes) {
+                        builder.add_node_ref(ref);
+                    }
+                }
+
+            }; // struct nodes_handler
+
+            struct members_handler {
+
+                template <typename TDummy>
+                static void set_value(RelationMemberListBuilder&, const TDummy&) noexcept {
+                }
+
+                static void set_value(RelationMemberListBuilder& builder, const attr::_member& member) {
+                    builder.add_member(member.value.type(), member.value.ref(), member.value.role());
+                }
+
+                template <typename TIterator>
+                static void set_value(RelationMemberListBuilder& builder, const attr::detail::members_from_iterator_pair<TIterator>& members) {
+                    for (const auto& member : members) {
+                        builder.add_member(member.type(), member.ref(), member.role());
+                    }
+                }
+
+            }; // struct members_handler
+
+            struct discussion_handler {
+
+                template <typename TDummy>
+                static void set_value(ChangesetDiscussionBuilder&, const TDummy&) noexcept {
+                }
+
+                static void set_value(ChangesetDiscussionBuilder& builder, const attr::_comment& comment) {
+                    builder.add_comment(comment.value.date(), comment.value.uid(), comment.value.user());
+                    builder.add_comment_text(comment.value.text());
+                }
+
+                template <typename TIterator>
+                static void set_value(ChangesetDiscussionBuilder& builder, const attr::detail::comments_from_iterator_pair<TIterator>& comments) {
+                    for (const auto& comment : comments) {
+                        builder.add_comment(comment.date(), comment.uid(), comment.user());
+                        builder.add_comment_text(comment.text());
+                    }
+                }
+
+            }; // struct discussion_handler
+
+            struct ring_handler {
+
+                template <typename TDummy>
+                static void set_value(AreaBuilder&, const TDummy&) noexcept {
+                }
+
+                template <typename TIterator>
+                static void set_value(AreaBuilder& parent, const attr::detail::outer_ring_from_iterator_pair<TIterator>& nodes) {
+                    OuterRingBuilder builder(parent.buffer(), &parent);
+                    for (const auto& ref : nodes) {
+                        builder.add_node_ref(ref);
+                    }
+                }
+
+                template <typename TIterator>
+                static void set_value(AreaBuilder& parent, const attr::detail::inner_ring_from_iterator_pair<TIterator>& nodes) {
+                    InnerRingBuilder builder(parent.buffer(), &parent);
+                    for (const auto& ref : nodes) {
+                        builder.add_node_ref(ref);
+                    }
+                }
+
+            }; // struct ring_handler
+
+            // ==============================================================
+
+            template <typename TBuilder, typename THandler, typename... TArgs>
+            inline typename std::enable_if<!is_handled_by<THandler, TArgs...>::value>::type
+            add_list(osmium::builder::Builder&, const TArgs&...) noexcept {
+            }
+
+            template <typename TBuilder, typename THandler, typename... TArgs>
+            inline typename std::enable_if<is_handled_by<THandler, TArgs...>::value>::type
+            add_list(osmium::builder::Builder& parent, const TArgs&... args) {
+                TBuilder builder(parent.buffer(), &parent);
+                (void)std::initializer_list<int>{
+                    (THandler::set_value(builder, args), 0)...
+                };
+            }
+
+            struct any_node_handlers : public node_handler, public tags_handler {};
+            struct any_way_handlers : public object_handler, public tags_handler, public nodes_handler {};
+            struct any_relation_handlers : public object_handler, public tags_handler, public members_handler {};
+            struct any_area_handlers : public object_handler, public tags_handler, public ring_handler {};
+            struct any_changeset_handlers : public changeset_handler, public tags_handler, public discussion_handler {};
+
+        } // namespace detail
+
+
+        /**
+         * Create a node using the given arguments and add it to the given buffer.
+         *
+         * @param buffer The buffer to which the node will be added.
+         * @param args The attributes of the node.
+         * @returns The position in the buffer where this node was added.
+         */
+        template <typename... TArgs>
+        inline size_t add_node(osmium::memory::Buffer& buffer, const TArgs&... args) {
+            static_assert(sizeof...(args) > 0, "add_node() must have buffer and at least one additional argument");
+            static_assert(detail::are_all_handled_by<detail::any_node_handlers, TArgs...>::value, "Attribute not allowed in add_node()");
+
+            NodeBuilder builder(buffer);
+
+            detail::add_basic<detail::node_handler>(builder, args...);
+            detail::add_user(builder, args...);
+            detail::add_list<TagListBuilder, detail::tags_handler>(builder, args...);
+
+            return buffer.commit();
+        }
+
+        /**
+         * Create a way using the given arguments and add it to the given buffer.
+         *
+         * @param buffer The buffer to which the way will be added.
+         * @param args The attributes of the way.
+         * @returns The position in the buffer where this way was added.
+         */
+        template <typename... TArgs>
+        inline size_t add_way(osmium::memory::Buffer& buffer, const TArgs&... args) {
+            static_assert(sizeof...(args) > 0, "add_way() must have buffer and at least one additional argument");
+            static_assert(detail::are_all_handled_by<detail::any_way_handlers, TArgs...>::value, "Attribute not allowed in add_way()");
+
+            WayBuilder builder(buffer);
+
+            detail::add_basic<detail::object_handler>(builder, args...);
+            detail::add_user(builder, args...);
+            detail::add_list<TagListBuilder, detail::tags_handler>(builder, args...);
+            detail::add_list<WayNodeListBuilder, detail::nodes_handler>(builder, args...);
+
+            return buffer.commit();
+        }
+
+        /**
+         * Create a relation using the given arguments and add it to the given buffer.
+         *
+         * @param buffer The buffer to which the relation will be added.
+         * @param args The attributes of the relation.
+         * @returns The position in the buffer where this relation was added.
+         */
+        template <typename... TArgs>
+        inline size_t add_relation(osmium::memory::Buffer& buffer, const TArgs&... args) {
+            static_assert(sizeof...(args) > 0, "add_relation() must have buffer and at least one additional argument");
+            static_assert(detail::are_all_handled_by<detail::any_relation_handlers, TArgs...>::value, "Attribute not allowed in add_relation()");
+
+            RelationBuilder builder(buffer);
+
+            detail::add_basic<detail::object_handler>(builder, args...);
+            detail::add_user(builder, args...);
+            detail::add_list<TagListBuilder, detail::tags_handler>(builder, args...);
+            detail::add_list<RelationMemberListBuilder, detail::members_handler>(builder, args...);
+
+            return buffer.commit();
+        }
+
+        /**
+         * Create a changeset using the given arguments and add it to the given buffer.
+         *
+         * @param buffer The buffer to which the changeset will be added.
+         * @param args The attributes of the changeset.
+         * @returns The position in the buffer where this changeset was added.
+         */
+        template <typename... TArgs>
+        inline size_t add_changeset(osmium::memory::Buffer& buffer, const TArgs&... args) {
+            static_assert(sizeof...(args) > 0, "add_changeset() must have buffer and at least one additional argument");
+            static_assert(detail::are_all_handled_by<detail::any_changeset_handlers, TArgs...>::value, "Attribute not allowed in add_changeset()");
+
+            ChangesetBuilder builder(buffer);
+
+            detail::add_basic<detail::changeset_handler>(builder, args...);
+            detail::add_user(builder, args...);
+            detail::add_list<TagListBuilder, detail::tags_handler>(builder, args...);
+            detail::add_list<ChangesetDiscussionBuilder, detail::discussion_handler>(builder, args...);
+
+            return buffer.commit();
+        }
+
+        /**
+         * Create a area using the given arguments and add it to the given buffer.
+         *
+         * @param buffer The buffer to which the area will be added.
+         * @param args The attributes of the area.
+         * @returns The position in the buffer where this area was added.
+         */
+        template <typename... TArgs>
+        inline size_t add_area(osmium::memory::Buffer& buffer, const TArgs&... args) {
+            static_assert(sizeof...(args) > 0, "add_area() must have buffer and at least one additional argument");
+            static_assert(detail::are_all_handled_by<detail::any_area_handlers, TArgs...>::value, "Attribute not allowed in add_area()");
+
+            AreaBuilder builder(buffer);
+
+            detail::add_basic<detail::object_handler>(builder, args...);
+            detail::add_user(builder, args...);
+            detail::add_list<TagListBuilder, detail::tags_handler>(builder, args...);
+
+            (void)std::initializer_list<int>{
+                (detail::ring_handler::set_value(builder, args), 0)...
+            };
+
+            return buffer.commit();
+        }
+
+        /**
+         * Create a WayNodeList using the given arguments and add it to the given buffer.
+         *
+         * @param buffer The buffer to which the list will be added.
+         * @param args The contents of the list.
+         * @returns The position in the buffer where this list was added.
+         */
+        template <typename... TArgs>
+        inline size_t add_way_node_list(osmium::memory::Buffer& buffer, const TArgs&... args) {
+            static_assert(sizeof...(args) > 0, "add_way_node_list() must have buffer and at least one additional argument");
+            static_assert(detail::are_all_handled_by<detail::nodes_handler, TArgs...>::value, "Attribute not allowed in add_way_node_list()");
+
+            {
+                WayNodeListBuilder builder(buffer);
+                (void)std::initializer_list<int>{
+                    (detail::nodes_handler::set_value(builder, args), 0)...
+                };
+            }
+
+            return buffer.commit();
+        }
+
+        /**
+         * Create a TagList using the given arguments and add it to the given buffer.
+         *
+         * @param buffer The buffer to which the list will be added.
+         * @param args The contents of the list.
+         * @returns The position in the buffer where this list was added.
+         */
+        template <typename... TArgs>
+        inline size_t add_tag_list(osmium::memory::Buffer& buffer, const TArgs&... args) {
+            static_assert(sizeof...(args) > 0, "add_tag_list() must have buffer and at least one additional argument");
+            static_assert(detail::are_all_handled_by<detail::tags_handler, TArgs...>::value, "Attribute not allowed in add_tag_list()");
+
+            {
+                TagListBuilder builder(buffer);
+                (void)std::initializer_list<int>{
+                    (detail::tags_handler::set_value(builder, args), 0)...
+                };
+            }
+
+            return buffer.commit();
+        }
+
+    } // namespace builder
+
+} // namespace osmium
+
+#endif // OSMIUM_BUILDER_ATTR_HPP

third_party/libosmium/include/osmium/builder/builder.hpp

@@ -0,0 +1,237 @@
+#ifndef OSMIUM_BUILDER_BUILDER_HPP
+#define OSMIUM_BUILDER_BUILDER_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <new>
+#include <string>
+#include <type_traits>
+
+#include <osmium/memory/buffer.hpp>
+#include <osmium/memory/item.hpp>
+#include <osmium/osm/types.hpp>
+#include <osmium/util/cast.hpp>
+
+namespace osmium {
+
+    /**
+     * @brief Classes for building OSM objects and other items in buffers
+     */
+    namespace builder {
+
+        class Builder {
+
+            osmium::memory::Buffer& m_buffer;
+            Builder* m_parent;
+            size_t m_item_offset;
+
+            Builder(const Builder&) = delete;
+            Builder(Builder&&) = delete;
+
+            Builder& operator=(const Builder&) = delete;
+            Builder& operator=(Builder&&) = delete;
+
+        protected:
+
+            explicit Builder(osmium::memory::Buffer& buffer, Builder* parent, osmium::memory::item_size_type size) :
+                m_buffer(buffer),
+                m_parent(parent),
+                m_item_offset(buffer.written()) {
+                m_buffer.reserve_space(size);
+                assert(buffer.is_aligned());
+                if (m_parent) {
+                    m_parent->add_size(size);
+                }
+            }
+
+            ~Builder() = default;
+
+            osmium::memory::Item& item() const {
+                return *reinterpret_cast<osmium::memory::Item*>(m_buffer.data() + m_item_offset);
+            }
+
+        public:
+
+            /**
+             * Add padding to buffer (if needed) to align data properly.
+             *
+             * This calculates how many padding bytes are needed and adds
+             * as many zero bytes to the buffer. It also adds this number
+             * to the size of the current item (if the "self" param is
+             * true) and recursively to all the parent items.
+             *
+             * @param self If true add number of padding bytes to size
+             *             of current item. Size is always added to
+             *             parent item (if any).
+             *
+             */
+            void add_padding(bool self = false) {
+                auto padding = osmium::memory::align_bytes - (size() % osmium::memory::align_bytes);
+                if (padding != osmium::memory::align_bytes) {
+                    std::fill_n(m_buffer.reserve_space(padding), padding, 0);
+                    if (self) {
+                        add_size(padding);
+                    } else if (m_parent) {
+                        m_parent->add_size(padding);
+                        assert(m_parent->size() % osmium::memory::align_bytes == 0);
+                    }
+                }
+            }
+
+            void add_size(uint32_t size) {
+                item().add_size(size);
+                if (m_parent) {
+                    m_parent->add_size(size);
+                }
+            }
+
+            uint32_t size() const noexcept {
+                return item().byte_size();
+            }
+
+            void add_item(const osmium::memory::Item* item) {
+                unsigned char* target = m_buffer.reserve_space(item->padded_size());
+                std::copy_n(reinterpret_cast<const unsigned char*>(item), item->padded_size(), target);
+                add_size(item->padded_size());
+            }
+
+            /**
+             * Reserve space for an object of class T in buffer and return
+             * pointer to it.
+             */
+            template <typename T>
+            T* reserve_space_for() {
+                assert(m_buffer.is_aligned());
+                return reinterpret_cast<T*>(m_buffer.reserve_space(sizeof(T)));
+            }
+
+            /**
+             * Append data to buffer.
+             *
+             * @param data Pointer to data.
+             * @param length Length of data in bytes. If data is a
+             *               \0-terminated string, length must contain the
+             *               \0 byte.
+             * @returns The number of bytes appended (length).
+             */
+            osmium::memory::item_size_type append(const char* data, const osmium::memory::item_size_type length) {
+                unsigned char* target = m_buffer.reserve_space(length);
+                std::copy_n(reinterpret_cast<const unsigned char*>(data), length, target);
+                return length;
+            }
+
+            /**
+             * Append \0-terminated string to buffer.
+             *
+             * @param str \0-terminated string.
+             * @returns The number of bytes appended (strlen(str) + 1).
+             */
+            osmium::memory::item_size_type append(const char* str) {
+                return append(str, static_cast<osmium::memory::item_size_type>(std::strlen(str) + 1));
+            }
+
+            /**
+             * Append '\0' to the buffer.
+             *
+             * @returns The number of bytes appended (always 1).
+             */
+            osmium::memory::item_size_type append_zero() {
+                *m_buffer.reserve_space(1) = '\0';
+                return 1;
+            }
+
+            /// Return the buffer this builder is using.
+            osmium::memory::Buffer& buffer() noexcept {
+                return m_buffer;
+            }
+
+        }; // class Builder
+
+        template <typename TItem>
+        class ObjectBuilder : public Builder {
+
+            static_assert(std::is_base_of<osmium::memory::Item, TItem>::value, "ObjectBuilder can only build objects derived from osmium::memory::Item");
+
+        public:
+
+            explicit ObjectBuilder(osmium::memory::Buffer& buffer, Builder* parent = nullptr) :
+                Builder(buffer, parent, sizeof(TItem)) {
+                new (&item()) TItem();
+            }
+
+            TItem& object() noexcept {
+                return static_cast<TItem&>(item());
+            }
+
+            /**
+             * Add user name to buffer.
+             *
+             * @param user Pointer to user name.
+             * @param length Length of user name (without \0 termination).
+             */
+            void add_user(const char* user, const string_size_type length) {
+                object().set_user_size(length + 1);
+                add_size(append(user, length) + append_zero());
+                add_padding(true);
+            }
+
+            /**
+             * Add user name to buffer.
+             *
+             * @param user Pointer to \0-terminated user name.
+             */
+            void add_user(const char* user) {
+                add_user(user, static_cast_with_assert<string_size_type>(std::strlen(user)));
+            }
+
+            /**
+             * Add user name to buffer.
+             *
+             * @param user User name.
+             */
+            void add_user(const std::string& user) {
+                add_user(user.data(), static_cast_with_assert<string_size_type>(user.size()));
+            }
+
+        }; // class ObjectBuilder
+
+    } // namespace builder
+
+} // namespace osmium
+
+#endif // OSMIUM_BUILDER_BUILDER_HPP

third_party/libosmium/include/osmium/builder/builder_helper.hpp

@@ -0,0 +1,120 @@
+#ifndef OSMIUM_BUILDER_BUILDER_HELPER_HPP
+#define OSMIUM_BUILDER_BUILDER_HELPER_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <cstddef>
+#include <initializer_list>
+#include <functional>
+#include <map>
+#include <utility>
+
+#include <osmium/builder/osm_object_builder.hpp>
+#include <osmium/memory/buffer.hpp>
+#include <osmium/util/compatibility.hpp>
+
+namespace osmium {
+
+    class NodeRef;
+    class TagList;
+    class WayNodeList;
+
+    namespace builder {
+
+        /**
+         * @deprecated
+         * Use osmium::builder::add_way_node_list() instead.
+         */
+        OSMIUM_DEPRECATED inline const osmium::WayNodeList& build_way_node_list(osmium::memory::Buffer& buffer, const std::initializer_list<osmium::NodeRef>& nodes) {
+            size_t pos = buffer.committed();
+            {
+                osmium::builder::WayNodeListBuilder wnl_builder(buffer);
+                for (const auto& node_ref : nodes) {
+                    wnl_builder.add_node_ref(node_ref);
+                }
+            }
+            buffer.commit();
+            return buffer.get<const osmium::WayNodeList>(pos);
+        }
+
+        /**
+         * @deprecated
+         * Use osmium::builder::add_tag_list() instead.
+         */
+        inline const osmium::TagList& build_tag_list(osmium::memory::Buffer& buffer, const std::initializer_list<std::pair<const char*, const char*>>& tags) {
+            size_t pos = buffer.committed();
+            {
+                osmium::builder::TagListBuilder tl_builder(buffer);
+                for (const auto& p : tags) {
+                    tl_builder.add_tag(p.first, p.second);
+                }
+            }
+            buffer.commit();
+            return buffer.get<const osmium::TagList>(pos);
+        }
+
+        /**
+         * @deprecated
+         * Use osmium::builder::add_tag_list() instead.
+         */
+        inline const osmium::TagList& build_tag_list_from_map(osmium::memory::Buffer& buffer, const std::map<const char*, const char*>& tags) {
+            size_t pos = buffer.committed();
+            {
+                osmium::builder::TagListBuilder tl_builder(buffer);
+                for (const auto& p : tags) {
+                    tl_builder.add_tag(p.first, p.second);
+                }
+            }
+            buffer.commit();
+            return buffer.get<const osmium::TagList>(pos);
+        }
+
+        /**
+         * @deprecated
+         * Use osmium::builder::add_tag_list() instead.
+         */
+        inline const osmium::TagList& build_tag_list_from_func(osmium::memory::Buffer& buffer, std::function<void(osmium::builder::TagListBuilder&)> func) {
+            size_t pos = buffer.committed();
+            {
+                osmium::builder::TagListBuilder tl_builder(buffer);
+                func(tl_builder);
+            }
+            buffer.commit();
+            return buffer.get<const osmium::TagList>(pos);
+        }
+
+    } // namespace builder
+
+} // namespace osmium
+
+#endif // OSMIUM_BUILDER_BUILDER_HELPER_HPP

third_party/libosmium/include/osmium/builder/osm_object_builder.hpp

@@ -0,0 +1,407 @@
+#ifndef OSMIUM_BUILDER_OSM_OBJECT_BUILDER_HPP
+#define OSMIUM_BUILDER_OSM_OBJECT_BUILDER_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <cstring>
+#include <initializer_list>
+#include <limits>
+#include <new>
+#include <stdexcept>
+#include <string>
+#include <utility>
+
+#include <osmium/builder/builder.hpp>
+#include <osmium/osm.hpp>
+#include <osmium/osm/item_type.hpp>
+#include <osmium/osm/location.hpp>
+#include <osmium/osm/node_ref.hpp>
+#include <osmium/osm/object.hpp>
+#include <osmium/osm/tag.hpp>
+#include <osmium/osm/types.hpp>
+
+namespace osmium {
+
+    namespace memory {
+        class Buffer;
+    } // namespace memory
+
+    namespace builder {
+
+        class TagListBuilder : public ObjectBuilder<TagList> {
+
+        public:
+
+            explicit TagListBuilder(osmium::memory::Buffer& buffer, Builder* parent = nullptr) :
+                ObjectBuilder<TagList>(buffer, parent) {
+            }
+
+            ~TagListBuilder() {
+                add_padding();
+            }
+
+            /**
+             * Add tag to buffer.
+             *
+             * @param key Tag key (0-terminated string).
+             * @param value Tag value (0-terminated string).
+             */
+            void add_tag(const char* key, const char* value) {
+                if (std::strlen(key) > osmium::max_osm_string_length) {
+                    throw std::length_error("OSM tag key is too long");
+                }
+                if (std::strlen(value) > osmium::max_osm_string_length) {
+                    throw std::length_error("OSM tag value is too long");
+                }
+                add_size(append(key) + append(value));
+            }
+
+            /**
+             * Add tag to buffer.
+             *
+             * @param key Pointer to tag key.
+             * @param key_length Length of key (not including the \0 byte).
+             * @param value Pointer to tag value.
+             * @param value_length Length of value (not including the \0 byte).
+             */
+            void add_tag(const char* key, const size_t key_length, const char* value, const size_t value_length) {
+                if (key_length > osmium::max_osm_string_length) {
+                    throw std::length_error("OSM tag key is too long");
+                }
+                if (value_length > osmium::max_osm_string_length) {
+                    throw std::length_error("OSM tag value is too long");
+                }
+                add_size(append(key,   osmium::memory::item_size_type(key_length))   + append_zero() +
+                         append(value, osmium::memory::item_size_type(value_length)) + append_zero());
+            }
+
+            /**
+             * Add tag to buffer.
+             *
+             * @param key Tag key.
+             * @param value Tag value.
+             */
+            void add_tag(const std::string& key, const std::string& value) {
+                if (key.size() > osmium::max_osm_string_length) {
+                    throw std::length_error("OSM tag key is too long");
+                }
+                if (value.size() > osmium::max_osm_string_length) {
+                    throw std::length_error("OSM tag value is too long");
+                }
+                add_size(append(key.data(),   osmium::memory::item_size_type(key.size())   + 1) +
+                         append(value.data(), osmium::memory::item_size_type(value.size()) + 1));
+            }
+
+            /**
+             * Add tag to buffer.
+             *
+             * @param tag Tag.
+             */
+            void add_tag(const osmium::Tag& tag) {
+                add_size(append(tag.key()) + append(tag.value()));
+            }
+
+            /**
+             * Add tag to buffer.
+             *
+             * @param tag Pair of key/value 0-terminated strings.
+             */
+            void add_tag(const std::pair<const char* const, const char* const>& tag) {
+                add_tag(tag.first, tag.second);
+            }
+            void add_tag(const std::pair<const char* const, const char*>& tag) {
+                add_tag(tag.first, tag.second);
+            }
+            void add_tag(const std::pair<const char*, const char* const>& tag) {
+                add_tag(tag.first, tag.second);
+            }
+            void add_tag(const std::pair<const char*, const char*>& tag) {
+                add_tag(tag.first, tag.second);
+            }
+
+            /**
+             * Add tag to buffer.
+             *
+             * @param tag Pair of std::string references.
+             */
+            void add_tag(const std::pair<const std::string&, const std::string&>& tag) {
+                add_tag(tag.first, tag.second);
+            }
+
+        }; // class TagListBuilder
+
+        template <typename T>
+        class NodeRefListBuilder : public ObjectBuilder<T> {
+
+        public:
+
+            explicit NodeRefListBuilder(osmium::memory::Buffer& buffer, Builder* parent = nullptr) :
+                ObjectBuilder<T>(buffer, parent) {
+            }
+
+            ~NodeRefListBuilder() {
+                static_cast<Builder*>(this)->add_padding();
+            }
+
+            void add_node_ref(const NodeRef& node_ref) {
+                new (static_cast<Builder*>(this)->reserve_space_for<osmium::NodeRef>()) osmium::NodeRef(node_ref);
+                static_cast<Builder*>(this)->add_size(sizeof(osmium::NodeRef));
+            }
+
+            void add_node_ref(const object_id_type ref, const osmium::Location& location = Location{}) {
+                add_node_ref(NodeRef(ref, location));
+            }
+
+        }; // class NodeRefListBuilder
+
+        typedef NodeRefListBuilder<WayNodeList> WayNodeListBuilder;
+        typedef NodeRefListBuilder<OuterRing> OuterRingBuilder;
+        typedef NodeRefListBuilder<InnerRing> InnerRingBuilder;
+
+        class RelationMemberListBuilder : public ObjectBuilder<RelationMemberList> {
+
+            /**
+             * Add role to buffer.
+             *
+             * @param member Relation member object where the length of the role
+             *               will be set.
+             * @param role The role.
+             * @param length Length of role (without \0 termination).
+             * @throws std:length_error If role is longer than osmium::max_osm_string_length
+             */
+            void add_role(osmium::RelationMember& member, const char* role, const size_t length) {
+                if (length > osmium::max_osm_string_length) {
+                    throw std::length_error("OSM relation member role is too long");
+                }
+                member.set_role_size(osmium::string_size_type(length) + 1);
+                add_size(append(role, osmium::memory::item_size_type(length)) + append_zero());
+                add_padding(true);
+            }
+
+        public:
+
+            explicit RelationMemberListBuilder(osmium::memory::Buffer& buffer, Builder* parent = nullptr) :
+                ObjectBuilder<RelationMemberList>(buffer, parent) {
+            }
+
+            ~RelationMemberListBuilder() {
+                add_padding();
+            }
+
+            /**
+             * Add a member to the relation.
+             *
+             * @param type The type (node, way, or relation).
+             * @param ref The ID of the member.
+             * @param role The role of the member.
+             * @param role_length Length of the role (without \0 termination).
+             * @param full_member Optional pointer to the member object. If it
+             *                    is available a copy will be added to the
+             *                    relation.
+             * @throws std:length_error If role_length is greater than
+             *         osmium::max_osm_string_length
+             */
+            void add_member(osmium::item_type type, object_id_type ref, const char* role, const size_t role_length, const osmium::OSMObject* full_member = nullptr) {
+                osmium::RelationMember* member = reserve_space_for<osmium::RelationMember>();
+                new (member) osmium::RelationMember(ref, type, full_member != nullptr);
+                add_size(sizeof(RelationMember));
+                add_role(*member, role, role_length);
+                if (full_member) {
+                    add_item(full_member);
+                }
+            }
+
+            /**
+             * Add a member to the relation.
+             *
+             * @param type The type (node, way, or relation).
+             * @param ref The ID of the member.
+             * @param role The role of the member (\0 terminated string).
+             * @param full_member Optional pointer to the member object. If it
+             *                    is available a copy will be added to the
+             *                    relation.
+             * @throws std:length_error If role is longer than osmium::max_osm_string_length
+             */
+            void add_member(osmium::item_type type, object_id_type ref, const char* role, const osmium::OSMObject* full_member = nullptr) {
+                add_member(type, ref, role, std::strlen(role), full_member);
+            }
+
+            /**
+             * Add a member to the relation.
+             *
+             * @param type The type (node, way, or relation).
+             * @param ref The ID of the member.
+             * @param role The role of the member.
+             * @param full_member Optional pointer to the member object. If it
+             *                    is available a copy will be added to the
+             *                    relation.
+             * @throws std:length_error If role is longer than osmium::max_osm_string_length
+             */
+            void add_member(osmium::item_type type, object_id_type ref, const std::string& role, const osmium::OSMObject* full_member = nullptr) {
+                add_member(type, ref, role.data(), role.size(), full_member);
+            }
+
+        }; // class RelationMemberListBuilder
+
+        class ChangesetDiscussionBuilder : public ObjectBuilder<ChangesetDiscussion> {
+
+            osmium::ChangesetComment* m_comment = nullptr;
+
+            void add_user(osmium::ChangesetComment& comment, const char* user, const size_t length) {
+                if (length > osmium::max_osm_string_length) {
+                    throw std::length_error("OSM user name is too long");
+                }
+                comment.set_user_size(osmium::string_size_type(length) + 1);
+                add_size(append(user, osmium::memory::item_size_type(length)) + append_zero());
+            }
+
+            void add_text(osmium::ChangesetComment& comment, const char* text, const size_t length) {
+                // XXX There is no limit on the length of a comment text. We
+                // limit it here to 2^16-2 characters, because that's all that
+                // will fit into our internal data structure. This is not ideal,
+                // and will have to be discussed and cleared up.
+                if (length > std::numeric_limits<osmium::string_size_type>::max() - 1) {
+                    throw std::length_error("OSM changeset comment is too long");
+                }
+                comment.set_text_size(osmium::string_size_type(length) + 1);
+                add_size(append(text, osmium::memory::item_size_type(length)) + append_zero());
+                add_padding(true);
+            }
+
+        public:
+
+            explicit ChangesetDiscussionBuilder(osmium::memory::Buffer& buffer, Builder* parent = nullptr) :
+                ObjectBuilder<ChangesetDiscussion>(buffer, parent) {
+            }
+
+            ~ChangesetDiscussionBuilder() {
+                assert(!m_comment && "You have to always call both add_comment() and then add_comment_text() in that order for each comment!");
+                add_padding();
+            }
+
+            void add_comment(osmium::Timestamp date, osmium::user_id_type uid, const char* user) {
+                assert(!m_comment && "You have to always call both add_comment() and then add_comment_text() in that order for each comment!");
+                m_comment = reserve_space_for<osmium::ChangesetComment>();
+                new (m_comment) osmium::ChangesetComment(date, uid);
+                add_size(sizeof(ChangesetComment));
+                add_user(*m_comment, user, std::strlen(user));
+            }
+
+            void add_comment_text(const char* text) {
+                assert(m_comment && "You have to always call both add_comment() and then add_comment_text() in that order for each comment!");
+                add_text(*m_comment, text, std::strlen(text));
+                m_comment = nullptr;
+            }
+
+            void add_comment_text(const std::string& text) {
+                assert(m_comment && "You have to always call both add_comment() and then add_comment_text() in that order for each comment!");
+                add_text(*m_comment, text.c_str(), text.size());
+                m_comment = nullptr;
+            }
+
+        }; // class ChangesetDiscussionBuilder
+
+        template <typename T>
+        class OSMObjectBuilder : public ObjectBuilder<T> {
+
+        public:
+
+            explicit OSMObjectBuilder(osmium::memory::Buffer& buffer, Builder* parent = nullptr) :
+                ObjectBuilder<T>(buffer, parent) {
+                static_cast<Builder*>(this)->reserve_space_for<string_size_type>();
+                static_cast<Builder*>(this)->add_size(sizeof(string_size_type));
+            }
+
+            void add_tags(const std::initializer_list<std::pair<const char*, const char*>>& tags) {
+                osmium::builder::TagListBuilder tl_builder(static_cast<Builder*>(this)->buffer(), this);
+                for (const auto& p : tags) {
+                    tl_builder.add_tag(p.first, p.second);
+                }
+            }
+
+        }; // class OSMObjectBuilder
+
+        typedef OSMObjectBuilder<osmium::Node> NodeBuilder;
+        typedef OSMObjectBuilder<osmium::Relation> RelationBuilder;
+
+        class WayBuilder : public OSMObjectBuilder<osmium::Way> {
+
+        public:
+
+            explicit WayBuilder(osmium::memory::Buffer& buffer, Builder* parent = nullptr) :
+                OSMObjectBuilder<osmium::Way>(buffer, parent) {
+            }
+
+            void add_node_refs(const std::initializer_list<osmium::NodeRef>& nodes) {
+                osmium::builder::WayNodeListBuilder builder(buffer(), this);
+                for (const auto& node_ref : nodes) {
+                    builder.add_node_ref(node_ref);
+                }
+            }
+
+        }; // class WayBuilder
+
+        class AreaBuilder : public OSMObjectBuilder<osmium::Area> {
+
+        public:
+
+            explicit AreaBuilder(osmium::memory::Buffer& buffer, Builder* parent = nullptr) :
+                OSMObjectBuilder<osmium::Area>(buffer, parent) {
+            }
+
+            /**
+             * Initialize area attributes from the attributes of the given object.
+             */
+            void initialize_from_object(const osmium::OSMObject& source) {
+                osmium::Area& area = object();
+                area.set_id(osmium::object_id_to_area_id(source.id(), source.type()));
+                area.set_version(source.version());
+                area.set_changeset(source.changeset());
+                area.set_timestamp(source.timestamp());
+                area.set_visible(source.visible());
+                area.set_uid(source.uid());
+
+                add_user(source.user());
+            }
+
+        }; // class AreaBuilder
+
+        typedef ObjectBuilder<osmium::Changeset> ChangesetBuilder;
+
+    } // namespace builder
+
+} // namespace osmium
+
+#endif // OSMIUM_BUILDER_OSM_OBJECT_BUILDER_HPP

third_party/libosmium/include/osmium/diff_handler.hpp

@@ -0,0 +1,66 @@
+#ifndef OSMIUM_DIFF_HANDLER_HPP
+#define OSMIUM_DIFF_HANDLER_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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/osm/diff_object.hpp>
+
+namespace osmium {
+
+    /**
+     * @brief Osmium diff handlers provide access to differences between OSM object versions
+     */
+    namespace diff_handler {
+
+        class DiffHandler {
+
+        public:
+
+            DiffHandler() = default;
+
+            void node(const osmium::DiffNode&) const {
+            }
+
+            void way(const osmium::DiffWay&) const {
+            }
+
+            void relation(const osmium::DiffRelation&) const {
+            }
+
+        }; // class DiffHandler
+
+    } // namespace diff_handler
+
+} // namespace osmium
+
+#endif // OSMIUM_DIFF_HANDLER_HPP

third_party/libosmium/include/osmium/diff_iterator.hpp

@@ -0,0 +1,135 @@
+#ifndef OSMIUM_DIFF_ITERATOR_HPP
+#define OSMIUM_DIFF_ITERATOR_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <iterator>
+#include <type_traits>
+
+#include <osmium/osm/diff_object.hpp>
+
+namespace osmium {
+
+    class OSMObject;
+
+    /**
+     * An input iterator wrapping any iterator over OSMObjects. When
+     * dereferenced it will yield DiffObject objects pointing to the
+     * underlying OSMObjects.
+     */
+    template <typename TBasicIterator>
+    class DiffIterator : public std::iterator<std::input_iterator_tag, const osmium::DiffObject> {
+
+        static_assert(std::is_base_of<osmium::OSMObject, typename TBasicIterator::value_type>::value, "TBasicIterator::value_type must derive from osmium::OSMObject");
+
+        TBasicIterator m_prev;
+        TBasicIterator m_curr;
+        TBasicIterator m_next;
+
+        const TBasicIterator m_end;
+
+        mutable osmium::DiffObject m_diff;
+
+        void set_diff() const noexcept {
+            assert(m_curr != m_end);
+
+            bool use_curr_for_prev =                    m_prev->type() != m_curr->type() || m_prev->id() != m_curr->id();
+            bool use_curr_for_next = m_next == m_end || m_next->type() != m_curr->type() || m_next->id() != m_curr->id();
+
+            m_diff = std::move(osmium::DiffObject{
+                *(use_curr_for_prev ? m_curr : m_prev),
+                *m_curr,
+                *(use_curr_for_next ? m_curr : m_next)
+            });
+        }
+
+    public:
+
+        DiffIterator(TBasicIterator begin, TBasicIterator end) :
+            m_prev(begin),
+            m_curr(begin),
+            m_next(begin == end ? begin : ++begin),
+            m_end(std::move(end)),
+            m_diff() {
+        }
+
+        DiffIterator& operator++() {
+            m_prev = std::move(m_curr);
+            m_curr = m_next;
+
+            if (m_next != m_end) {
+                ++m_next;
+            }
+
+            return *this;
+        }
+
+        DiffIterator operator++(int) {
+            DiffIterator tmp(*this);
+            operator++();
+            return tmp;
+        }
+
+        bool operator==(const DiffIterator& rhs) const noexcept {
+            return m_curr == rhs.m_curr && m_end == rhs.m_end;
+        }
+
+        bool operator!=(const DiffIterator& rhs) const noexcept {
+            return !(*this == rhs);
+        }
+
+        reference operator*() const noexcept {
+            set_diff();
+            return m_diff;
+        }
+
+        pointer operator->() const noexcept {
+            set_diff();
+            return &m_diff;
+        }
+
+    }; // class DiffIterator
+
+    /**
+     * Create a DiffIterator based on the given iterators.
+     */
+    template <typename TBasicIterator>
+    inline DiffIterator<TBasicIterator> make_diff_iterator(TBasicIterator begin,
+                                                           TBasicIterator end) {
+        return DiffIterator<TBasicIterator>{begin, end};
+    }
+
+} // namespace osmium
+
+#endif // OSMIUM_DIFF_ITERATOR_HPP

third_party/libosmium/include/osmium/diff_visitor.hpp

@@ -0,0 +1,104 @@
+#ifndef OSMIUM_DIFF_VISITOR_HPP
+#define OSMIUM_DIFF_VISITOR_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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/diff_iterator.hpp>
+#include <osmium/io/input_iterator.hpp>
+#include <osmium/memory/buffer.hpp>
+#include <osmium/osm/diff_object.hpp>
+#include <osmium/osm/item_type.hpp>
+
+namespace osmium {
+
+    namespace detail {
+
+        template <typename THandler>
+        inline void apply_diff_iterator_recurse(const osmium::DiffObject& diff, THandler& handler) {
+            switch (diff.type()) {
+                case osmium::item_type::node:
+                    handler.node(static_cast<const osmium::DiffNode&>(diff));
+                    break;
+                case osmium::item_type::way:
+                    handler.way(static_cast<const osmium::DiffWay&>(diff));
+                    break;
+                case osmium::item_type::relation:
+                    handler.relation(static_cast<const osmium::DiffRelation&>(diff));
+                    break;
+                default:
+                    throw osmium::unknown_type();
+            }
+        }
+
+        template <typename THandler, typename... TRest>
+        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, more...);
+        }
+
+    } // namespace detail
+
+    template <typename TIterator, typename... THandlers>
+    inline void apply_diff(TIterator it, TIterator end, THandlers&... handlers) {
+        using diff_iterator = osmium::DiffIterator<TIterator>;
+
+        diff_iterator dit(it, end);
+        diff_iterator dend(end, end);
+
+        for (; dit != dend; ++dit) {
+            detail::apply_diff_iterator_recurse(*dit, handlers...);
+        }
+    }
+
+    class OSMObject;
+
+    template <typename TSource, typename... THandlers>
+    inline void apply_diff(TSource& source, THandlers&... handlers) {
+        apply_diff(osmium::io::InputIterator<TSource, osmium::OSMObject> {source},
+                   osmium::io::InputIterator<TSource, osmium::OSMObject> {},
+                   handlers...);
+    }
+
+    template <typename... THandlers>
+    inline void apply_diff(osmium::memory::Buffer& buffer, THandlers&... handlers) {
+        apply_diff(buffer.begin(), buffer.end(), handlers...);
+    }
+
+    template <typename... THandlers>
+    inline void apply_diff(const osmium::memory::Buffer& buffer, THandlers&... handlers) {
+        apply_diff(buffer.cbegin(), buffer.cend(), handlers...);
+    }
+
+} // namespace osmium
+
+#endif // OSMIUM_DIFF_VISITOR_HPP

third_party/libosmium/include/osmium/dynamic_handler.hpp

@@ -0,0 +1,190 @@
+#ifndef OSMIUM_DYNAMIC_HANDLER_HPP
+#define OSMIUM_DYNAMIC_HANDLER_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <memory>
+#include <utility>
+
+#include <osmium/fwd.hpp>
+#include <osmium/handler.hpp>
+
+namespace osmium {
+
+    namespace handler {
+
+        namespace detail {
+
+            class HandlerWrapperBase {
+
+            public:
+
+                virtual ~HandlerWrapperBase() {
+                }
+
+                virtual void node(const osmium::Node&) {
+                }
+
+                virtual void way(const osmium::Way&) {
+                }
+
+                virtual void relation(const osmium::Relation&) {
+                }
+
+                virtual void area(const osmium::Area&) {
+                }
+
+                virtual void changeset(const osmium::Changeset&) {
+                }
+
+                virtual void flush() {
+                }
+
+            }; // class HandlerWrapperBase
+
+
+            // The following uses trick from
+            // http://stackoverflow.com/questions/257288/is-it-possible-to-write-a-c-template-to-check-for-a-functions-existence
+            // to either call handler style functions or visitor style operator().
+
+#define OSMIUM_DYNAMIC_HANDLER_DISPATCH(_name_, _type_) \
+template <typename THandler> \
+auto _name_##_dispatch(THandler& handler, const osmium::_type_& object, int) -> decltype(handler._name_(object), void()) { \
+    handler._name_(object); \
+} \
+template <typename THandler> \
+auto _name_##_dispatch(THandler& handler, const osmium::_type_& object, long) -> decltype(handler(object), void()) { \
+    handler(object); \
+}
+
+            OSMIUM_DYNAMIC_HANDLER_DISPATCH(node, Node)
+            OSMIUM_DYNAMIC_HANDLER_DISPATCH(way, Way)
+            OSMIUM_DYNAMIC_HANDLER_DISPATCH(relation, Relation)
+            OSMIUM_DYNAMIC_HANDLER_DISPATCH(changeset, Changeset)
+            OSMIUM_DYNAMIC_HANDLER_DISPATCH(area, Area)
+
+            template <typename THandler>
+            auto flush_dispatch(THandler& handler, int) -> decltype(handler.flush(), void()) {
+                handler.flush();
+            }
+
+            template <typename THandler>
+            void flush_dispatch(THandler&, long) {}
+
+            template <typename THandler>
+            class HandlerWrapper : public HandlerWrapperBase {
+
+                THandler m_handler;
+
+            public:
+
+                template <typename... TArgs>
+                HandlerWrapper(TArgs&&... args) :
+                    m_handler(std::forward<TArgs>(args)...) {
+                }
+
+                void node(const osmium::Node& node) final {
+                    node_dispatch(m_handler, node, 0);
+                }
+
+                void way(const osmium::Way& way) final {
+                    way_dispatch(m_handler, way, 0);
+                }
+
+                void relation(const osmium::Relation& relation) final {
+                    relation_dispatch(m_handler, relation, 0);
+                }
+
+                void area(const osmium::Area& area) final {
+                    area_dispatch(m_handler, area, 0);
+                }
+
+                void changeset(const osmium::Changeset& changeset) final {
+                    changeset_dispatch(m_handler, changeset, 0);
+                }
+
+                void flush() final {
+                    flush_dispatch(m_handler, 0);
+                }
+
+            }; // class HandlerWrapper
+
+        } // namespace detail
+
+        class DynamicHandler : public osmium::handler::Handler {
+
+            typedef std::unique_ptr<osmium::handler::detail::HandlerWrapperBase> impl_ptr;
+            impl_ptr m_impl;
+
+        public:
+
+            DynamicHandler() :
+                m_impl(impl_ptr(new osmium::handler::detail::HandlerWrapperBase)) {
+            }
+
+            template <typename THandler, typename... TArgs>
+            void set(TArgs&&... args) {
+                m_impl = impl_ptr(new osmium::handler::detail::HandlerWrapper<THandler>(std::forward<TArgs>(args)...));
+            }
+
+            void node(const osmium::Node& node) {
+                m_impl->node(node);
+            }
+
+            void way(const osmium::Way& way) {
+                m_impl->way(way);
+            }
+
+            void relation(const osmium::Relation& relation) {
+                m_impl->relation(relation);
+            }
+
+            void area(const osmium::Area& area) {
+                m_impl->area(area);
+            }
+
+            void changeset(const osmium::Changeset& changeset) {
+                m_impl->changeset(changeset);
+            }
+
+            void flush() {
+                m_impl->flush();
+            }
+
+        }; // class DynamicHandler
+
+    } // namespace handler
+
+} // namespace osmium
+
+#endif // OSMIUM_DYNAMIC_HANDLER_HPP

third_party/libosmium/include/osmium/experimental/flex_reader.hpp

@@ -0,0 +1,137 @@
+#ifndef OSMIUM_EXPERIMENTAL_FLEX_READER_HPP
+#define OSMIUM_EXPERIMENTAL_FLEX_READER_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <string>
+#include <vector>
+
+#include <osmium/area/assembler.hpp>
+#include <osmium/area/multipolygon_collector.hpp>
+#include <osmium/handler/node_locations_for_ways.hpp>
+#include <osmium/io/file.hpp>
+#include <osmium/io/header.hpp>
+#include <osmium/io/reader.hpp>
+#include <osmium/memory/buffer.hpp>
+#include <osmium/osm/entity_bits.hpp>
+#include <osmium/visitor.hpp>
+
+namespace osmium {
+
+    /**
+     * @brief Experimental code that is not "officially" supported.
+     */
+    namespace experimental {
+
+        template <typename TLocationHandler>
+        class FlexReader {
+
+            bool m_with_areas;
+            osmium::osm_entity_bits::type m_entities;
+
+            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, TLocationHandler& location_handler, osmium::osm_entity_bits::type entities = osmium::osm_entity_bits::nwr) :
+                m_with_areas((entities & osmium::osm_entity_bits::area) != 0),
+                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_location_handler(location_handler),
+                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, TLocationHandler& location_handler, osmium::osm_entity_bits::type entities = osmium::osm_entity_bits::nwr) :
+                FlexReader(osmium::io::File(filename), location_handler, entities) {
+            }
+
+            explicit FlexReader(const char* filename, TLocationHandler& location_handler, osmium::osm_entity_bits::type entities = osmium::osm_entity_bits::nwr) :
+                FlexReader(osmium::io::File(filename), location_handler, entities) {
+            }
+
+            osmium::memory::Buffer read() {
+                osmium::memory::Buffer buffer = m_reader.read();
+
+                if (buffer) {
+                    if (m_with_areas) {
+                        std::vector<osmium::memory::Buffer> area_buffers;
+                        osmium::apply(buffer, m_location_handler, m_collector.handler([&area_buffers](osmium::memory::Buffer&& area_buffer) {
+                            area_buffers.push_back(std::move(area_buffer));
+                        }));
+                        for (const osmium::memory::Buffer& b : area_buffers) {
+                            buffer.add_buffer(b);
+                            buffer.commit();
+                        }
+                    } else if (m_entities & (osmium::osm_entity_bits::node | osmium::osm_entity_bits::way)) {
+                        osmium::apply(buffer, m_location_handler);
+                    }
+                }
+
+                return buffer;
+            }
+
+            osmium::io::Header header() {
+                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

third_party/libosmium/include/osmium/fwd.hpp

@@ -0,0 +1,70 @@
+#ifndef OSMIUM_FWD_HPP
+#define OSMIUM_FWD_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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.
+
+*/
+
+/**
+ *
+ * @file
+ *
+ * This file contains forward declarations for commonly used Osmium classes.
+ *
+ */
+
+namespace osmium {
+
+    class Area;
+    class Box;
+    class Changeset;
+    class ChangesetComment;
+    class ChangesetDiscussion;
+    class InnerRing;
+    class Location;
+    class Node;
+    class NodeRef;
+    class NodeRefList;
+    class OSMEntity;
+    class OSMObject;
+    class OuterRing;
+    class Relation;
+    class RelationMemberList;
+    class Segment;
+    class Tag;
+    class TagList;
+    class Timestamp;
+    class Way;
+    class WayNodeList;
+
+} // namespace osmium
+
+#endif // OSMIUM_FWD_HPP

third_party/libosmium/include/osmium/geom/coordinates.hpp

@@ -0,0 +1,96 @@
+#ifndef OSMIUM_GEOM_COORDINATES_HPP
+#define OSMIUM_GEOM_COORDINATES_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <iosfwd>
+#include <string>
+
+#include <osmium/osm/location.hpp>
+#include <osmium/util/double.hpp>
+
+namespace osmium {
+
+    namespace geom {
+
+        struct Coordinates {
+
+            double x;
+            double y;
+
+            explicit Coordinates(double cx, double cy) noexcept : x(cx), y(cy) {
+            }
+
+            Coordinates(const osmium::Location& location) : x(location.lon()), y(location.lat()) {
+            }
+
+            void append_to_string(std::string& s, const char infix, int precision) const {
+                osmium::util::double2string(s, x, precision);
+                s += infix;
+                osmium::util::double2string(s, y, precision);
+            }
+
+            void append_to_string(std::string& s, const char prefix, const char infix, const char suffix, int precision) const {
+                s += prefix;
+                append_to_string(s, infix, precision);
+                s += suffix;
+            }
+
+        }; // struct coordinates
+
+        /**
+         * Compare whether two Coordinates are identical. Might not give the
+         * right result if the coordinates have been the result of some
+         * calculation that introduced rounding errors.
+         */
+        inline bool operator==(const Coordinates& lhs, const Coordinates& rhs) noexcept {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+            return lhs.x == rhs.x && lhs.y == rhs.y;
+#pragma GCC diagnostic pop
+        }
+
+        inline bool operator!=(const Coordinates& lhs, const Coordinates& rhs) noexcept {
+            return ! operator==(lhs, rhs);
+        }
+
+        template <typename TChar, typename TTraits>
+        inline std::basic_ostream<TChar, TTraits>& operator<<(std::basic_ostream<TChar, TTraits>& out, const Coordinates& c) {
+            return out << '(' << c.x << ',' << c.y << ')';
+        }
+
+    } // namespace geom
+
+} // namespace osmium
+
+#endif // OSMIUM_GEOM_COORDINATES_HPP

third_party/libosmium/include/osmium/geom/factory.hpp

@@ -0,0 +1,419 @@
+#ifndef OSMIUM_GEOM_FACTORY_HPP
+#define OSMIUM_GEOM_FACTORY_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <cstddef>
+#include <stdexcept>
+#include <string>
+#include <utility>
+
+#include <osmium/geom/coordinates.hpp>
+#include <osmium/memory/collection.hpp>
+#include <osmium/memory/item.hpp>
+#include <osmium/osm/area.hpp>
+#include <osmium/osm/item_type.hpp>
+#include <osmium/osm/location.hpp>
+#include <osmium/osm/node.hpp>
+#include <osmium/osm/node_ref.hpp>
+#include <osmium/osm/way.hpp>
+
+namespace osmium {
+
+    /**
+     * Exception thrown when an invalid geometry is encountered. An example
+     * would be a linestring with less than two points.
+     */
+    class geometry_error : public std::runtime_error {
+
+        std::string m_message;
+        osmium::object_id_type m_id;
+
+    public:
+
+        explicit geometry_error(const std::string& message, const char* object_type = "", osmium::object_id_type id = 0) :
+            std::runtime_error(message),
+            m_message(message),
+            m_id(id) {
+            if (m_id != 0) {
+                m_message += " (";
+                m_message += object_type;
+                m_message += "_id=";
+                m_message += std::to_string(m_id);
+                m_message += ")";
+            }
+        }
+
+        void set_id(const char* object_type, osmium::object_id_type id) {
+            if (m_id == 0 && id != 0) {
+                m_message += " (";
+                m_message += object_type;
+                m_message += "_id=";
+                m_message += std::to_string(id);
+                m_message += ")";
+            }
+            m_id = id;
+        }
+
+        osmium::object_id_type id() const noexcept {
+            return m_id;
+        }
+
+        const char* what() const noexcept override {
+            return m_message.c_str();
+        }
+
+    }; // struct geometry_error
+
+    /**
+     * @brief Everything related to geometry handling.
+     */
+    namespace geom {
+
+        /**
+         * Which nodes of a way to use for a linestring.
+         */
+        enum class use_nodes : bool {
+            unique = true, ///< Remove consecutive nodes with same location.
+            all    = false ///< Use all nodes.
+        }; // enum class use_nodes
+
+        /**
+         * Which direction the linestring created from a way
+         * should have.
+         */
+        enum class direction : bool {
+            backward = true, ///< Linestring has reverse direction.
+            forward  = false ///< Linestring has same direction as way.
+        }; // enum class direction
+
+        /**
+         * This pseudo projection just returns its WGS84 input unchanged.
+         * Used as a template parameter if a real projection is not needed.
+         */
+        class IdentityProjection {
+
+        public:
+
+            Coordinates operator()(osmium::Location location) const {
+                return Coordinates{location.lon(), location.lat()};
+            }
+
+            int epsg() const noexcept {
+                return 4326;
+            }
+
+            std::string proj_string() const {
+                return "+proj=longlat +datum=WGS84 +no_defs";
+            }
+
+        }; // class IdentityProjection
+
+        /**
+         * Geometry factory.
+         */
+        template <typename TGeomImpl, typename TProjection = IdentityProjection>
+        class GeometryFactory {
+
+            /**
+             * Add all points of an outer or inner ring to a multipolygon.
+             */
+            void add_points(const osmium::OuterRing& nodes) {
+                osmium::Location last_location;
+                for (const osmium::NodeRef& node_ref : nodes) {
+                    if (last_location != node_ref.location()) {
+                        last_location = node_ref.location();
+                        m_impl.multipolygon_add_location(m_projection(last_location));
+                    }
+                }
+            }
+
+            TProjection m_projection;
+            TGeomImpl m_impl;
+
+        public:
+
+            /**
+             * Constructor for default initialized projection.
+             */
+            template <typename... TArgs>
+            explicit GeometryFactory<TGeomImpl, TProjection>(TArgs&&... args) :
+                m_projection(),
+                m_impl(std::forward<TArgs>(args)...) {
+            }
+
+            /**
+             * Constructor for explicitly initialized projection. Note that the
+             * projection is moved into the GeometryFactory.
+             */
+            template <typename... TArgs>
+            explicit GeometryFactory<TGeomImpl, TProjection>(TProjection&& projection, TArgs&&... args) :
+                m_projection(std::move(projection)),
+                m_impl(std::forward<TArgs>(args)...) {
+            }
+
+            typedef TProjection projection_type;
+            typedef typename TGeomImpl::point_type        point_type;
+            typedef typename TGeomImpl::linestring_type   linestring_type;
+            typedef typename TGeomImpl::polygon_type      polygon_type;
+            typedef typename TGeomImpl::multipolygon_type multipolygon_type;
+            typedef typename TGeomImpl::ring_type         ring_type;
+
+            int epsg() const {
+                return m_projection.epsg();
+            }
+
+            std::string proj_string() const {
+                return m_projection.proj_string();
+            }
+
+            /* Point */
+
+            point_type create_point(const osmium::Location& location) const {
+                return m_impl.make_point(m_projection(location));
+            }
+
+            point_type create_point(const osmium::Node& node) {
+                try {
+                    return create_point(node.location());
+                } catch (osmium::geometry_error& e) {
+                    e.set_id("node", node.id());
+                    throw;
+                }
+            }
+
+            point_type create_point(const osmium::NodeRef& node_ref) {
+                try {
+                    return create_point(node_ref.location());
+                } catch (osmium::geometry_error& e) {
+                    e.set_id("node", node_ref.ref());
+                    throw;
+                }
+            }
+
+            /* LineString */
+
+            void linestring_start() {
+                m_impl.linestring_start();
+            }
+
+            template <typename TIter>
+            size_t fill_linestring(TIter it, TIter end) {
+                size_t num_points = 0;
+                for (; it != end; ++it, ++num_points) {
+                    m_impl.linestring_add_location(m_projection(it->location()));
+                }
+                return num_points;
+            }
+
+            template <typename TIter>
+            size_t fill_linestring_unique(TIter it, TIter end) {
+                size_t num_points = 0;
+                osmium::Location last_location;
+                for (; it != end; ++it) {
+                    if (last_location != it->location()) {
+                        last_location = it->location();
+                        m_impl.linestring_add_location(m_projection(last_location));
+                        ++num_points;
+                    }
+                }
+                return num_points;
+            }
+
+            linestring_type linestring_finish(size_t num_points) {
+                return m_impl.linestring_finish(num_points);
+            }
+
+            linestring_type create_linestring(const osmium::WayNodeList& wnl, use_nodes un = use_nodes::unique, direction dir = direction::forward) {
+                linestring_start();
+                size_t num_points = 0;
+
+                if (un == use_nodes::unique) {
+                    osmium::Location last_location;
+                    switch (dir) {
+                        case direction::forward:
+                            num_points = fill_linestring_unique(wnl.cbegin(), wnl.cend());
+                            break;
+                        case direction::backward:
+                            num_points = fill_linestring_unique(wnl.crbegin(), wnl.crend());
+                            break;
+                    }
+                } else {
+                    switch (dir) {
+                        case direction::forward:
+                            num_points = fill_linestring(wnl.cbegin(), wnl.cend());
+                            break;
+                        case direction::backward:
+                            num_points = fill_linestring(wnl.crbegin(), wnl.crend());
+                            break;
+                    }
+                }
+
+                if (num_points < 2) {
+                    throw osmium::geometry_error("need at least two points for linestring");
+                }
+
+                return linestring_finish(num_points);
+            }
+
+            linestring_type create_linestring(const osmium::Way& way, use_nodes un=use_nodes::unique, direction dir=direction::forward) {
+                try {
+                    return create_linestring(way.nodes(), un, dir);
+                } catch (osmium::geometry_error& e) {
+                    e.set_id("way", way.id());
+                    throw;
+                }
+            }
+
+            /* Polygon */
+
+            void polygon_start() {
+                m_impl.polygon_start();
+            }
+
+            template <typename TIter>
+            size_t fill_polygon(TIter it, TIter end) {
+                size_t num_points = 0;
+                for (; it != end; ++it, ++num_points) {
+                    m_impl.polygon_add_location(m_projection(it->location()));
+                }
+                return num_points;
+            }
+
+            template <typename TIter>
+            size_t fill_polygon_unique(TIter it, TIter end) {
+                size_t num_points = 0;
+                osmium::Location last_location;
+                for (; it != end; ++it) {
+                    if (last_location != it->location()) {
+                        last_location = it->location();
+                        m_impl.polygon_add_location(m_projection(last_location));
+                        ++num_points;
+                    }
+                }
+                return num_points;
+            }
+
+            polygon_type polygon_finish(size_t num_points) {
+                return m_impl.polygon_finish(num_points);
+            }
+
+            polygon_type create_polygon(const osmium::WayNodeList& wnl, use_nodes un = use_nodes::unique, direction dir = direction::forward) {
+                polygon_start();
+                size_t num_points = 0;
+
+                if (un == use_nodes::unique) {
+                    osmium::Location last_location;
+                    switch (dir) {
+                        case direction::forward:
+                            num_points = fill_polygon_unique(wnl.cbegin(), wnl.cend());
+                            break;
+                        case direction::backward:
+                            num_points = fill_polygon_unique(wnl.crbegin(), wnl.crend());
+                            break;
+                    }
+                } else {
+                    switch (dir) {
+                        case direction::forward:
+                            num_points = fill_polygon(wnl.cbegin(), wnl.cend());
+                            break;
+                        case direction::backward:
+                            num_points = fill_polygon(wnl.crbegin(), wnl.crend());
+                            break;
+                    }
+                }
+
+                if (num_points < 4) {
+                    throw osmium::geometry_error("need at least four points for polygon");
+                }
+
+                return polygon_finish(num_points);
+            }
+
+            polygon_type create_polygon(const osmium::Way& way, use_nodes un=use_nodes::unique, direction dir=direction::forward) {
+                try {
+                    return create_polygon(way.nodes(), un, dir);
+                } catch (osmium::geometry_error& e) {
+                    e.set_id("way", way.id());
+                    throw;
+                }
+            }
+
+            /* MultiPolygon */
+
+            multipolygon_type create_multipolygon(const osmium::Area& area) {
+                try {
+                    size_t num_polygons = 0;
+                    size_t num_rings = 0;
+                    m_impl.multipolygon_start();
+
+                    for (auto it = area.cbegin(); it != area.cend(); ++it) {
+                        const osmium::OuterRing& ring = static_cast<const osmium::OuterRing&>(*it);
+                        if (it->type() == osmium::item_type::outer_ring) {
+                            if (num_polygons > 0) {
+                                m_impl.multipolygon_polygon_finish();
+                            }
+                            m_impl.multipolygon_polygon_start();
+                            m_impl.multipolygon_outer_ring_start();
+                            add_points(ring);
+                            m_impl.multipolygon_outer_ring_finish();
+                            ++num_rings;
+                            ++num_polygons;
+                        } else if (it->type() == osmium::item_type::inner_ring) {
+                            m_impl.multipolygon_inner_ring_start();
+                            add_points(ring);
+                            m_impl.multipolygon_inner_ring_finish();
+                            ++num_rings;
+                        }
+                    }
+
+                    // if there are no rings, this area is invalid
+                    if (num_rings == 0) {
+                        throw osmium::geometry_error("area contains no rings");
+                    }
+
+                    m_impl.multipolygon_polygon_finish();
+                    return m_impl.multipolygon_finish();
+                } catch (osmium::geometry_error& e) {
+                    e.set_id("area", area.id());
+                    throw;
+                }
+            }
+
+        }; // class GeometryFactory
+
+    } // namespace geom
+
+} // namespace osmium
+
+#endif // OSMIUM_GEOM_FACTORY_HPP

third_party/libosmium/include/osmium/geom/geojson.hpp

@@ -0,0 +1,160 @@
+#ifndef OSMIUM_GEOM_GEOJSON_HPP
+#define OSMIUM_GEOM_GEOJSON_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <string>
+#include <utility>
+
+#include <osmium/geom/coordinates.hpp>
+#include <osmium/geom/factory.hpp>
+
+namespace osmium {
+
+    namespace geom {
+
+        namespace detail {
+
+            class GeoJSONFactoryImpl {
+
+                std::string m_str;
+                int m_precision;
+
+            public:
+
+                typedef std::string point_type;
+                typedef std::string linestring_type;
+                typedef std::string polygon_type;
+                typedef std::string multipolygon_type;
+                typedef std::string ring_type;
+
+                GeoJSONFactoryImpl(int precision = 7) :
+                    m_precision(precision) {
+                }
+
+                /* Point */
+
+                // { "type": "Point", "coordinates": [100.0, 0.0] }
+                point_type make_point(const osmium::geom::Coordinates& xy) const {
+                    std::string str {"{\"type\":\"Point\",\"coordinates\":"};
+                    xy.append_to_string(str, '[', ',', ']', m_precision);
+                    str += "}";
+                    return str;
+                }
+
+                /* LineString */
+
+                // { "type": "LineString", "coordinates": [ [100.0, 0.0], [101.0, 1.0] ] }
+                void linestring_start() {
+                    m_str = "{\"type\":\"LineString\",\"coordinates\":[";
+                }
+
+                void linestring_add_location(const osmium::geom::Coordinates& xy) {
+                    xy.append_to_string(m_str, '[', ',', ']', m_precision);
+                    m_str += ',';
+                }
+
+                linestring_type linestring_finish(size_t /* num_points */) {
+                    assert(!m_str.empty());
+                    std::string str;
+
+                    using std::swap;
+                    swap(str, m_str);
+
+                    str.back() = ']';
+                    str += "}";
+                    return str;
+                }
+
+                /* MultiPolygon */
+
+                void multipolygon_start() {
+                    m_str = "{\"type\":\"MultiPolygon\",\"coordinates\":[";
+                }
+
+                void multipolygon_polygon_start() {
+                    m_str += '[';
+                }
+
+                void multipolygon_polygon_finish() {
+                    m_str += "],";
+                }
+
+                void multipolygon_outer_ring_start() {
+                    m_str += '[';
+                }
+
+                void multipolygon_outer_ring_finish() {
+                    assert(!m_str.empty());
+                    m_str.back() = ']';
+                }
+
+                void multipolygon_inner_ring_start() {
+                    m_str += ",[";
+                }
+
+                void multipolygon_inner_ring_finish() {
+                    assert(!m_str.empty());
+                    m_str.back() = ']';
+                }
+
+                void multipolygon_add_location(const osmium::geom::Coordinates& xy) {
+                    xy.append_to_string(m_str, '[', ',', ']', m_precision);
+                    m_str += ',';
+                }
+
+                multipolygon_type multipolygon_finish() {
+                    assert(!m_str.empty());
+                    std::string str;
+
+                    using std::swap;
+                    swap(str, m_str);
+
+                    str.back() = ']';
+                    str += "}";
+                    return str;
+                }
+
+            }; // class GeoJSONFactoryImpl
+
+        } // namespace detail
+
+        template <typename TProjection = IdentityProjection>
+        using GeoJSONFactory = GeometryFactory<osmium::geom::detail::GeoJSONFactoryImpl, TProjection>;
+
+    } // namespace geom
+
+} // namespace osmium
+
+#endif // OSMIUM_GEOM_GEOJSON_HPP

third_party/libosmium/include/osmium/geom/geos.hpp

@@ -0,0 +1,240 @@
+#ifndef OSMIUM_GEOM_GEOS_HPP
+#define OSMIUM_GEOM_GEOS_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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.
+
+*/
+
+/**
+ * @file
+ *
+ * This file contains code for conversion of OSM geometries into GDAL
+ * geometries.
+ *
+ * @attention If you include this file, you'll need to link with `libgeos`.
+ */
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/CoordinateSequence.h>
+#include <geos/geom/CoordinateSequenceFactory.h>
+#include <geos/geom/GeometryFactory.h>
+#include <geos/geom/LinearRing.h>
+#include <geos/geom/MultiPolygon.h>
+#include <geos/geom/Point.h>
+#include <geos/geom/Polygon.h>
+#include <geos/geom/PrecisionModel.h>
+#include <geos/util/GEOSException.h>
+
+#include <osmium/geom/factory.hpp>
+#include <osmium/geom/coordinates.hpp>
+
+// MSVC doesn't support throw_with_nested yet
+#ifdef _MSC_VER
+# define THROW throw
+#else
+# define THROW std::throw_with_nested
+#endif
+
+namespace osmium {
+
+    struct geos_geometry_error : public geometry_error {
+
+        geos_geometry_error(const char* message) :
+            geometry_error(std::string("geometry creation failed in GEOS library: ") + message) {
+        }
+
+    }; // struct geos_geometry_error
+
+    namespace geom {
+
+        namespace detail {
+
+            class GEOSFactoryImpl {
+
+                std::unique_ptr<const geos::geom::PrecisionModel> m_precision_model;
+                std::unique_ptr<geos::geom::GeometryFactory> m_our_geos_factory;
+                geos::geom::GeometryFactory* m_geos_factory;
+
+                std::unique_ptr<geos::geom::CoordinateSequence> m_coordinate_sequence;
+                std::vector<std::unique_ptr<geos::geom::LinearRing>> m_rings;
+                std::vector<std::unique_ptr<geos::geom::Polygon>> m_polygons;
+
+            public:
+
+                typedef std::unique_ptr<geos::geom::Point>        point_type;
+                typedef std::unique_ptr<geos::geom::LineString>   linestring_type;
+                typedef std::unique_ptr<geos::geom::Polygon>      polygon_type;
+                typedef std::unique_ptr<geos::geom::MultiPolygon> multipolygon_type;
+                typedef std::unique_ptr<geos::geom::LinearRing>   ring_type;
+
+                explicit GEOSFactoryImpl(geos::geom::GeometryFactory& geos_factory) :
+                    m_precision_model(nullptr),
+                    m_our_geos_factory(nullptr),
+                    m_geos_factory(&geos_factory) {
+                }
+
+                explicit GEOSFactoryImpl(int srid = -1) :
+                    m_precision_model(new geos::geom::PrecisionModel),
+                    m_our_geos_factory(new geos::geom::GeometryFactory(m_precision_model.get(), srid)),
+                    m_geos_factory(m_our_geos_factory.get()) {
+                }
+
+                /* Point */
+
+                point_type make_point(const osmium::geom::Coordinates& xy) const {
+                    try {
+                        return point_type(m_geos_factory->createPoint(geos::geom::Coordinate(xy.x, xy.y)));
+                    } catch (geos::util::GEOSException& e) {
+                        THROW(osmium::geos_geometry_error(e.what()));
+                    }
+                }
+
+                /* LineString */
+
+                void linestring_start() {
+                    try {
+                        m_coordinate_sequence.reset(m_geos_factory->getCoordinateSequenceFactory()->create(static_cast<size_t>(0), 2));
+                    } catch (geos::util::GEOSException& e) {
+                        THROW(osmium::geos_geometry_error(e.what()));
+                    }
+                }
+
+                void linestring_add_location(const osmium::geom::Coordinates& xy) {
+                    try {
+                        m_coordinate_sequence->add(geos::geom::Coordinate(xy.x, xy.y));
+                    } catch (geos::util::GEOSException& e) {
+                        THROW(osmium::geos_geometry_error(e.what()));
+                    }
+                }
+
+                linestring_type linestring_finish(size_t /* num_points */) {
+                    try {
+                        return linestring_type(m_geos_factory->createLineString(m_coordinate_sequence.release()));
+                    } catch (geos::util::GEOSException& e) {
+                        THROW(osmium::geos_geometry_error(e.what()));
+                    }
+                }
+
+                /* MultiPolygon */
+
+                void multipolygon_start() {
+                    m_polygons.clear();
+                }
+
+                void multipolygon_polygon_start() {
+                    m_rings.clear();
+                }
+
+                void multipolygon_polygon_finish() {
+                    try {
+                        assert(!m_rings.empty());
+                        auto inner_rings = new std::vector<geos::geom::Geometry*>;
+                        std::transform(std::next(m_rings.begin(), 1), m_rings.end(), std::back_inserter(*inner_rings), [](std::unique_ptr<geos::geom::LinearRing>& r) {
+                            return r.release();
+                        });
+                        m_polygons.emplace_back(m_geos_factory->createPolygon(m_rings[0].release(), inner_rings));
+                        m_rings.clear();
+                    } catch (geos::util::GEOSException& e) {
+                        THROW(osmium::geos_geometry_error(e.what()));
+                    }
+                }
+
+                void multipolygon_outer_ring_start() {
+                    try {
+                        m_coordinate_sequence.reset(m_geos_factory->getCoordinateSequenceFactory()->create(static_cast<size_t>(0), 2));
+                    } catch (geos::util::GEOSException& e) {
+                        THROW(osmium::geos_geometry_error(e.what()));
+                    }
+                }
+
+                void multipolygon_outer_ring_finish() {
+                    try {
+                        m_rings.emplace_back(m_geos_factory->createLinearRing(m_coordinate_sequence.release()));
+                    } catch (geos::util::GEOSException& e) {
+                        THROW(osmium::geos_geometry_error(e.what()));
+                    }
+                }
+
+                void multipolygon_inner_ring_start() {
+                    try {
+                        m_coordinate_sequence.reset(m_geos_factory->getCoordinateSequenceFactory()->create(static_cast<size_t>(0), 2));
+                    } catch (geos::util::GEOSException& e) {
+                        THROW(osmium::geos_geometry_error(e.what()));
+                    }
+                }
+
+                void multipolygon_inner_ring_finish() {
+                    try {
+                        m_rings.emplace_back(m_geos_factory->createLinearRing(m_coordinate_sequence.release()));
+                    } catch (geos::util::GEOSException& e) {
+                        THROW(osmium::geos_geometry_error(e.what()));
+                    }
+                }
+
+                void multipolygon_add_location(const osmium::geom::Coordinates& xy) {
+                    try {
+                        m_coordinate_sequence->add(geos::geom::Coordinate(xy.x, xy.y));
+                    } catch (geos::util::GEOSException& e) {
+                        THROW(osmium::geos_geometry_error(e.what()));
+                    }
+                }
+
+                multipolygon_type multipolygon_finish() {
+                    try {
+                        auto polygons = new std::vector<geos::geom::Geometry*>;
+                        std::transform(m_polygons.begin(), m_polygons.end(), std::back_inserter(*polygons), [](std::unique_ptr<geos::geom::Polygon>& p) {
+                            return p.release();
+                        });
+                        m_polygons.clear();
+                        return multipolygon_type(m_geos_factory->createMultiPolygon(polygons));
+                    } catch (geos::util::GEOSException& e) {
+                        THROW(osmium::geos_geometry_error(e.what()));
+                    }
+                }
+
+            }; // class GEOSFactoryImpl
+
+        } // namespace detail
+
+        template <typename TProjection = IdentityProjection>
+        using GEOSFactory = GeometryFactory<osmium::geom::detail::GEOSFactoryImpl, TProjection>;
+
+    } // namespace geom
+
+} // namespace osmium
+
+#undef THROW
+
+#endif // OSMIUM_GEOM_GEOS_HPP

third_party/libosmium/include/osmium/geom/haversine.hpp

@@ -0,0 +1,94 @@
+#ifndef OSMIUM_GEOM_HAVERSINE_HPP
+#define OSMIUM_GEOM_HAVERSINE_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <cmath>
+#include <iterator>
+
+#include <osmium/geom/coordinates.hpp>
+#include <osmium/geom/util.hpp>
+#include <osmium/osm/node_ref.hpp>
+#include <osmium/osm/way.hpp>
+
+namespace osmium {
+
+    namespace geom {
+
+        /**
+         * @brief Functions to calculate arc distance on Earth using the haversine formula.
+         *
+         * See http://en.wikipedia.org/wiki/Haversine_formula
+         *
+         * Implementation derived from
+         * http://blog.julien.cayzac.name/2008/10/arc-and-distance-between-two-points-on.html
+         */
+        namespace haversine {
+
+            /// @brief Earth's quadratic mean radius for WGS84
+            constexpr double EARTH_RADIUS_IN_METERS = 6372797.560856;
+
+            /**
+             * Calculate distance in meters between two sets of coordinates.
+             */
+            inline double distance(const osmium::geom::Coordinates& c1, const osmium::geom::Coordinates& c2) {
+                double lonh = sin(deg_to_rad(c1.x - c2.x) * 0.5);
+                lonh *= lonh;
+                double lath = sin(deg_to_rad(c1.y - c2.y) * 0.5);
+                lath *= lath;
+                const double tmp = cos(deg_to_rad(c1.y)) * cos(deg_to_rad(c2.y));
+                return 2.0 * EARTH_RADIUS_IN_METERS * asin(sqrt(lath + tmp*lonh));
+            }
+
+            /**
+             * Calculate length of way.
+             */
+            inline double distance(const osmium::WayNodeList& wnl) {
+                double sum_length = 0;
+
+                for (auto it = wnl.begin(); it != wnl.end(); ++it) {
+                    if (std::next(it) != wnl.end()) {
+                        sum_length += distance(it->location(), std::next(it)->location());
+                    }
+                }
+
+                return sum_length;
+            }
+
+        } // namespace haversine
+
+    } // namespace geom
+
+} // namespace osmium
+
+#endif // OSMIUM_GEOM_HAVERSINE_HPP

third_party/libosmium/include/osmium/geom/mercator_projection.hpp

@@ -0,0 +1,110 @@
+#ifndef OSMIUM_GEOM_MERCATOR_PROJECTION_HPP
+#define OSMIUM_GEOM_MERCATOR_PROJECTION_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <cmath>
+#include <string>
+
+#include <osmium/geom/coordinates.hpp>
+#include <osmium/geom/util.hpp>
+#include <osmium/osm/location.hpp>
+
+namespace osmium {
+
+    namespace geom {
+
+        namespace detail {
+
+            constexpr double earth_radius_for_epsg3857 = 6378137.0;
+            constexpr double max_coordinate_epsg3857 = 20037508.34;
+
+            constexpr inline double lon_to_x(double lon) {
+                return earth_radius_for_epsg3857 * deg_to_rad(lon);
+            }
+
+            inline double lat_to_y(double lat) { // not constexpr because math functions aren't
+                return earth_radius_for_epsg3857 * std::log(std::tan(osmium::geom::PI/4 + deg_to_rad(lat)/2));
+            }
+
+            constexpr inline double x_to_lon(double x) {
+                return rad_to_deg(x) / earth_radius_for_epsg3857;
+            }
+
+            inline double y_to_lat(double y) { // not constexpr because math functions aren't
+                return rad_to_deg(2 * std::atan(std::exp(y / earth_radius_for_epsg3857)) - osmium::geom::PI/2);
+            }
+
+        } // namespace detail
+
+        /**
+         * The maximum latitude that can be projected with the Web Mercator
+         * (EPSG:3857) projection.
+         */
+        constexpr double MERCATOR_MAX_LAT = 85.0511288;
+
+        inline Coordinates lonlat_to_mercator(const Coordinates& c) {
+            return Coordinates(detail::lon_to_x(c.x), detail::lat_to_y(c.y));
+        }
+
+        inline Coordinates mercator_to_lonlat(const Coordinates& c) {
+            return Coordinates(detail::x_to_lon(c.x), detail::y_to_lat(c.y));
+        }
+
+        /**
+         * Functor that does projection from WGS84 (EPSG:4326) to "Web
+         * Mercator" (EPSG:3857)
+         */
+        class MercatorProjection {
+
+        public:
+
+            Coordinates operator()(osmium::Location location) const {
+                return Coordinates {detail::lon_to_x(location.lon()), detail::lat_to_y(location.lat())};
+            }
+
+            int epsg() const noexcept {
+                return 3857;
+            }
+
+            std::string proj_string() const {
+                return "+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +wktext +no_defs";
+            }
+
+        }; // class MercatorProjection
+
+    } // namespace geom
+
+} // namespace osmium
+
+#endif // OSMIUM_GEOM_MERCATOR_PROJECTION_HPP

third_party/libosmium/include/osmium/geom/ogr.hpp

@@ -0,0 +1,178 @@
+#ifndef OSMIUM_GEOM_OGR_HPP
+#define OSMIUM_GEOM_OGR_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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.
+
+*/
+
+/**
+ * @file
+ *
+ * This file contains code for conversion of OSM geometries into OGR
+ * geometries.
+ *
+ * @attention If you include this file, you'll need to link with `libgdal`.
+ */
+
+#include <cassert>
+#include <cstddef>
+#include <memory>
+#include <utility>
+
+#include <ogr_geometry.h>
+
+#include <osmium/geom/coordinates.hpp>
+#include <osmium/geom/factory.hpp>
+
+namespace osmium {
+
+    namespace geom {
+
+        namespace detail {
+
+            class OGRFactoryImpl {
+
+            public:
+
+                typedef std::unique_ptr<OGRPoint>        point_type;
+                typedef std::unique_ptr<OGRLineString>   linestring_type;
+                typedef std::unique_ptr<OGRPolygon>      polygon_type;
+                typedef std::unique_ptr<OGRMultiPolygon> multipolygon_type;
+                typedef std::unique_ptr<OGRLinearRing>   ring_type;
+
+            private:
+
+                linestring_type   m_linestring;
+                multipolygon_type m_multipolygon;
+                polygon_type      m_polygon;
+                ring_type         m_ring;
+
+            public:
+
+                OGRFactoryImpl() = default;
+
+                /* Point */
+
+                point_type make_point(const osmium::geom::Coordinates& xy) const {
+                    return point_type(new OGRPoint(xy.x, xy.y));
+                }
+
+                /* LineString */
+
+                void linestring_start() {
+                    m_linestring = std::unique_ptr<OGRLineString>(new OGRLineString());
+                }
+
+                void linestring_add_location(const osmium::geom::Coordinates& xy) {
+                    assert(!!m_linestring);
+                    m_linestring->addPoint(xy.x, xy.y);
+                }
+
+                linestring_type linestring_finish(size_t /* num_points */) {
+                    return std::move(m_linestring);
+                }
+
+                /* Polygon */
+
+                void polygon_start() {
+                    m_ring = std::unique_ptr<OGRLinearRing>(new OGRLinearRing());
+                }
+
+                void polygon_add_location(const osmium::geom::Coordinates& xy) {
+                    assert(!!m_ring);
+                    m_ring->addPoint(xy.x, xy.y);
+                }
+
+                polygon_type polygon_finish(size_t /* num_points */) {
+                    std::unique_ptr<OGRPolygon> polygon = std::unique_ptr<OGRPolygon>(new OGRPolygon());
+                    polygon->addRingDirectly(m_ring.release());
+                    return polygon;
+                }
+
+                /* MultiPolygon */
+
+                void multipolygon_start() {
+                    m_multipolygon.reset(new OGRMultiPolygon());
+                }
+
+                void multipolygon_polygon_start() {
+                    m_polygon.reset(new OGRPolygon());
+                }
+
+                void multipolygon_polygon_finish() {
+                    assert(!!m_multipolygon);
+                    assert(!!m_polygon);
+                    m_multipolygon->addGeometryDirectly(m_polygon.release());
+                }
+
+                void multipolygon_outer_ring_start() {
+                    m_ring.reset(new OGRLinearRing());
+                }
+
+                void multipolygon_outer_ring_finish() {
+                    assert(!!m_polygon);
+                    assert(!!m_ring);
+                    m_polygon->addRingDirectly(m_ring.release());
+                }
+
+                void multipolygon_inner_ring_start() {
+                    m_ring.reset(new OGRLinearRing());
+                }
+
+                void multipolygon_inner_ring_finish() {
+                    assert(!!m_polygon);
+                    assert(!!m_ring);
+                    m_polygon->addRingDirectly(m_ring.release());
+                }
+
+                void multipolygon_add_location(const osmium::geom::Coordinates& xy) {
+                    assert(!!m_polygon);
+                    assert(!!m_ring);
+                    m_ring->addPoint(xy.x, xy.y);
+                }
+
+                multipolygon_type multipolygon_finish() {
+                    assert(!!m_multipolygon);
+                    return std::move(m_multipolygon);
+                }
+
+            }; // class OGRFactoryImpl
+
+        } // namespace detail
+
+        template <typename TProjection = IdentityProjection>
+        using OGRFactory = GeometryFactory<osmium::geom::detail::OGRFactoryImpl, TProjection>;
+
+    } // namespace geom
+
+} // namespace osmium
+
+#endif // OSMIUM_GEOM_OGR_HPP

third_party/libosmium/include/osmium/geom/projection.hpp

@@ -0,0 +1,170 @@
+#ifndef OSMIUM_GEOM_PROJECTION_HPP
+#define OSMIUM_GEOM_PROJECTION_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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.
+
+*/
+
+/**
+ * @file
+ *
+ * This file contains code for projecting OSM locations to arbitrary
+ * coordinate reference systems. It is based on the Proj.4 library.
+ *
+ * @attention If you include this file, you'll need to link with `libproj`.
+ */
+
+#include <memory>
+#include <string>
+
+#include <proj_api.h>
+
+#include <osmium/geom/coordinates.hpp>
+#include <osmium/geom/util.hpp>
+#include <osmium/osm/location.hpp>
+
+namespace osmium {
+
+    namespace geom {
+
+        /**
+         * C++ wrapper for a Coordinate Reference System of the proj library.
+         */
+        class CRS {
+
+            struct ProjCRSDeleter {
+                void operator()(void* crs) {
+                    pj_free(crs);
+                }
+            }; // struct ProjCRSDeleter
+
+            std::unique_ptr<void, ProjCRSDeleter> m_crs;
+
+        public:
+
+            CRS(const std::string& crs) :
+                m_crs(pj_init_plus(crs.c_str()), ProjCRSDeleter()) {
+                if (!m_crs) {
+                    throw osmium::projection_error(std::string("creation of CRS failed: ") + pj_strerrno(*pj_get_errno_ref()));
+                }
+            }
+
+            CRS(int epsg) :
+                CRS(std::string("+init=epsg:") + std::to_string(epsg)) {
+            }
+
+            /**
+             * Get underlying projPJ handle from proj library.
+             */
+            projPJ get() const {
+                return m_crs.get();
+            }
+
+            bool is_latlong() const {
+                return pj_is_latlong(m_crs.get()) != 0;
+            }
+
+            bool is_geocent() const {
+                return pj_is_geocent(m_crs.get()) != 0;
+            }
+
+        }; // class CRS
+
+        /**
+         * Transform coordinates from one CRS into another. Wraps the same
+         * function of the proj library.
+         *
+         * Coordinates have to be in radians and are produced in radians.
+         *
+         * @throws osmmium::projection_error if the projection fails
+         */
+        inline Coordinates transform(const CRS& src, const CRS& dest, Coordinates c) {
+            int result = pj_transform(src.get(), dest.get(), 1, 1, &c.x, &c.y, nullptr);
+            if (result != 0) {
+                throw osmium::projection_error(std::string("projection failed: ") + pj_strerrno(result));
+            }
+            return c;
+        }
+
+        /**
+         * Functor that does projection from WGS84 (EPSG:4326) to the given
+         * CRS.
+         */
+        class Projection {
+
+            int m_epsg;
+            std::string m_proj_string;
+            CRS m_crs_wgs84 {4326};
+            CRS m_crs_user;
+
+        public:
+
+            Projection(const std::string& proj_string) :
+                m_epsg(-1),
+                m_proj_string(proj_string),
+                m_crs_user(proj_string) {
+            }
+
+            Projection(int epsg) :
+                m_epsg(epsg),
+                m_proj_string(std::string("+init=epsg:") + std::to_string(epsg)),
+                m_crs_user(epsg) {
+            }
+
+            Coordinates operator()(osmium::Location location) const {
+                Coordinates c {location.lon(), location.lat()};
+
+                if (m_epsg != 4326) {
+                    c = transform(m_crs_wgs84, m_crs_user, Coordinates(deg_to_rad(location.lon()), deg_to_rad(location.lat())));
+                    if (m_crs_user.is_latlong()) {
+                        c.x = rad_to_deg(c.x);
+                        c.y = rad_to_deg(c.y);
+                    }
+                }
+
+                return c;
+            }
+
+            int epsg() const noexcept {
+                return m_epsg;
+            }
+
+            std::string proj_string() const {
+                return m_proj_string;
+            }
+
+        }; // class Projection
+
+    } // namespace geom
+
+} // namespace osmium
+
+#endif // OSMIUM_GEOM_PROJECTION_HPP

third_party/libosmium/include/osmium/geom/rapid_geojson.hpp

@@ -0,0 +1,190 @@
+#ifndef OSMIUM_GEOM_RAPID_GEOJSON_HPP
+#define OSMIUM_GEOM_RAPID_GEOJSON_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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/geom/coordinates.hpp>
+#include <osmium/geom/factory.hpp>
+
+namespace osmium {
+
+    namespace geom {
+
+        namespace detail {
+
+            /**
+             * A geometry factory implementation that can be used with the
+             * RapidJSON (https://github.com/miloyip/rapidjson) JSON writer.
+             */
+            template <typename TWriter>
+            class RapidGeoJSONFactoryImpl {
+
+                TWriter* m_writer;
+
+            public:
+
+                typedef void point_type;
+                typedef void linestring_type;
+                typedef void polygon_type;
+                typedef void multipolygon_type;
+                typedef void ring_type;
+
+                RapidGeoJSONFactoryImpl(TWriter& writer) :
+                    m_writer(&writer) {
+                }
+
+                /* Point */
+
+                // { "type": "Point", "coordinates": [100.0, 0.0] }
+                point_type make_point(const osmium::geom::Coordinates& xy) const {
+                    m_writer->String("geometry");
+                    m_writer->StartObject();
+                    m_writer->String("type");
+                    m_writer->String("Point");
+                    m_writer->String("coordinates");
+                    m_writer->StartArray();
+                    m_writer->Double(xy.x);
+                    m_writer->Double(xy.y);
+                    m_writer->EndArray();
+                    m_writer->EndObject();
+                }
+
+                /* LineString */
+
+                // { "type": "LineString", "coordinates": [ [100.0, 0.0], [101.0, 1.0] ] }
+                void linestring_start() {
+                    m_writer->String("geometry");
+                    m_writer->StartObject();
+                    m_writer->String("type");
+                    m_writer->String("LineString");
+                    m_writer->String("coordinates");
+                    m_writer->StartArray();
+                }
+
+                void linestring_add_location(const osmium::geom::Coordinates& xy) {
+                    m_writer->StartArray();
+                    m_writer->Double(xy.x);
+                    m_writer->Double(xy.y);
+                    m_writer->EndArray();
+                }
+
+                linestring_type linestring_finish(size_t /* num_points */) {
+                    m_writer->EndArray();
+                    m_writer->EndObject();
+                }
+
+                /* Polygon */
+
+                // { "type": "Polygon", "coordinates": [[[100.0, 0.0], [101.0, 1.0]]] }
+                void polygon_start() {
+                    m_writer->String("geometry");
+                    m_writer->StartObject();
+                    m_writer->String("type");
+                    m_writer->String("Polygon");
+                    m_writer->String("coordinates");
+                    m_writer->StartArray();
+                    m_writer->StartArray();
+                }
+
+                void polygon_add_location(const osmium::geom::Coordinates& xy) {
+                    m_writer->StartArray();
+                    m_writer->Double(xy.x);
+                    m_writer->Double(xy.y);
+                    m_writer->EndArray();
+                }
+
+                polygon_type polygon_finish(size_t /* num_points */) {
+                    m_writer->EndArray();
+                    m_writer->EndArray();
+                    m_writer->EndObject();
+                }
+
+                /* MultiPolygon */
+
+                void multipolygon_start() {
+                    m_writer->String("geometry");
+                    m_writer->StartObject();
+                    m_writer->String("type");
+                    m_writer->String("MultiPolygon");
+                    m_writer->String("coordinates");
+                    m_writer->StartArray();
+                }
+
+                void multipolygon_polygon_start() {
+                    m_writer->StartArray();
+                }
+
+                void multipolygon_polygon_finish() {
+                    m_writer->EndArray();
+                }
+
+                void multipolygon_outer_ring_start() {
+                    m_writer->StartArray();
+                }
+
+                void multipolygon_outer_ring_finish() {
+                    m_writer->EndArray();
+                }
+
+                void multipolygon_inner_ring_start() {
+                    m_writer->StartArray();
+                }
+
+                void multipolygon_inner_ring_finish() {
+                    m_writer->EndArray();
+                }
+
+                void multipolygon_add_location(const osmium::geom::Coordinates& xy) {
+                    m_writer->StartArray();
+                    m_writer->Double(xy.x);
+                    m_writer->Double(xy.y);
+                    m_writer->EndArray();
+                }
+
+                multipolygon_type multipolygon_finish() {
+                    m_writer->EndArray();
+                    m_writer->EndObject();
+                }
+
+            }; // class RapidGeoJSONFactoryImpl
+
+        } // namespace detail
+
+        template <typename TWriter, typename TProjection = IdentityProjection>
+        using RapidGeoJSONFactory = GeometryFactory<detail::RapidGeoJSONFactoryImpl<TWriter>, TProjection>;
+
+    } // namespace geom
+
+} // namespace osmium
+
+#endif // OSMIUM_GEOM_RAPID_GEOJSON_HPP

third_party/libosmium/include/osmium/geom/relations.hpp

@@ -0,0 +1,57 @@
+#ifndef OSMIUM_GEOM_RELATIONS_HPP
+#define OSMIUM_GEOM_RELATIONS_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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/osm/box.hpp>
+#include <osmium/osm/location.hpp>
+
+namespace osmium {
+
+    namespace geom {
+
+        /**
+         * Check whether one geometry contains another.
+         */
+        inline bool contains(const osmium::Box& a, const osmium::Box& b) {
+            return ((a.bottom_left().x() >= b.bottom_left().x()) &&
+                    (a.top_right().x()   <= b.top_right().x())   &&
+                    (a.bottom_left().y() >= b.bottom_left().y()) &&
+                    (a.top_right().y()   <= b.top_right().y()));
+        }
+
+    } // namespace geom
+
+} // namespace osmium
+
+#endif // OSMIUM_GEOM_RELATIONS_HPP

third_party/libosmium/include/osmium/geom/tile.hpp

@@ -0,0 +1,101 @@
+#ifndef OSMIUM_GEOM_TILE_HPP
+#define OSMIUM_GEOM_TILE_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <cstdint>
+
+#include <osmium/geom/mercator_projection.hpp>
+
+namespace osmium {
+
+    namespace geom {
+
+        namespace detail {
+
+            template <typename T>
+            inline T restrict_to_range(T value, T min, T max) {
+                if (value < min) return min;
+                if (value > max) return max;
+                return value;
+            }
+
+        } // namespace detail
+
+        /**
+         * A tile in the usual Mercator projection.
+         */
+        struct Tile {
+
+            uint32_t x;
+            uint32_t y;
+            uint32_t z;
+
+            explicit Tile(uint32_t zoom, uint32_t tx, uint32_t ty) noexcept : x(tx), y(ty), z(zoom) {
+            }
+
+            explicit Tile(uint32_t zoom, const osmium::Location& location) :
+                z(zoom) {
+                osmium::geom::Coordinates c = lonlat_to_mercator(location);
+                const int32_t n = 1 << zoom;
+                const double scale = detail::max_coordinate_epsg3857 * 2 / n;
+                x = uint32_t(detail::restrict_to_range<int32_t>(int32_t((c.x + detail::max_coordinate_epsg3857) / scale), 0, n-1));
+                y = uint32_t(detail::restrict_to_range<int32_t>(int32_t((detail::max_coordinate_epsg3857 - c.y) / scale), 0, n-1));
+            }
+
+        }; // struct Tile
+
+        inline bool operator==(const Tile& a, const Tile& b) {
+            return a.z == b.z && a.x == b.x && a.y == b.y;
+        }
+
+        inline bool operator!=(const Tile& a, const Tile& b) {
+            return ! (a == b);
+        }
+
+        /**
+         * This defines an arbitrary order on tiles for use in std::map etc.
+         */
+        inline bool operator<(const Tile& a, const Tile& b) {
+            if (a.z < b.z) return true;
+            if (a.z > b.z) return false;
+            if (a.x < b.x) return true;
+            if (a.x > b.x) return false;
+            return a.y < b.y;
+        }
+
+    } // namespace geom
+
+} // namespace osmium
+
+#endif // OSMIUM_GEOM_TILE_HPP

third_party/libosmium/include/osmium/geom/util.hpp

@@ -0,0 +1,75 @@
+#ifndef OSMIUM_GEOM_UTIL_HPP
+#define OSMIUM_GEOM_UTIL_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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>
+#include <string>
+
+namespace osmium {
+
+    /**
+     * Exception thrown when a projection object can not be initialized or the
+     * projection of some coordinates can not be calculated.
+     */
+    struct projection_error : public std::runtime_error {
+
+        projection_error(const std::string& what) :
+            std::runtime_error(what) {
+        }
+
+        projection_error(const char* what) :
+            std::runtime_error(what) {
+        }
+
+    }; // struct projection_error
+
+    namespace geom {
+
+        constexpr double PI = 3.14159265358979323846;
+
+        /// Convert angle from degrees to radians.
+        inline constexpr double deg_to_rad(double degree) noexcept {
+            return degree * (PI / 180.0);
+        }
+
+        /// Convert angle from radians to degrees.
+        inline constexpr double rad_to_deg(double radians) noexcept {
+            return radians * (180.0 / PI);
+        }
+
+    } // namespace geom
+
+} // namespace osmium
+
+#endif // OSMIUM_GEOM_UTIL_HPP

third_party/libosmium/include/osmium/geom/wkb.hpp

@@ -0,0 +1,273 @@
+#ifndef OSMIUM_GEOM_WKB_HPP
+#define OSMIUM_GEOM_WKB_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <cstddef>
+#include <cstdint>
+#include <string>
+
+#include <osmium/geom/coordinates.hpp>
+#include <osmium/geom/factory.hpp>
+#include <osmium/util/cast.hpp>
+#include <osmium/util/endian.hpp>
+
+namespace osmium {
+
+    namespace geom {
+
+        enum class wkb_type : bool {
+            wkb  = false,
+            ewkb = true
+        }; // enum class wkb_type
+
+        enum class out_type : bool {
+            binary = false,
+            hex    = true
+        }; // enum class out_type
+
+        namespace detail {
+
+            template <typename T>
+            inline void str_push(std::string& str, T data) {
+                size_t size = str.size();
+                str.resize(size + sizeof(T));
+                std::copy_n(reinterpret_cast<char*>(&data), sizeof(T), &str[size]);
+            }
+
+            inline std::string convert_to_hex(const std::string& str) {
+                static const char* lookup_hex = "0123456789ABCDEF";
+                std::string out;
+
+                for (char c : str) {
+                    out += lookup_hex[(c >> 4) & 0xf];
+                    out += lookup_hex[c & 0xf];
+                }
+
+                return out;
+            }
+
+            class WKBFactoryImpl {
+
+                /// OSM data always uses SRID 4326 (WGS84).
+                static constexpr uint32_t srid = 4326;
+
+                /**
+                * Type of WKB geometry.
+                * These definitions are from
+                * 99-049_OpenGIS_Simple_Features_Specification_For_SQL_Rev_1.1.pdf (for WKB)
+                * and http://trac.osgeo.org/postgis/browser/trunk/doc/ZMSgeoms.txt (for EWKB).
+                * They are used to encode geometries into the WKB format.
+                */
+                enum wkbGeometryType : uint32_t {
+                    wkbPoint               = 1,
+                    wkbLineString          = 2,
+                    wkbPolygon             = 3,
+                    wkbMultiPoint          = 4,
+                    wkbMultiLineString     = 5,
+                    wkbMultiPolygon        = 6,
+                    wkbGeometryCollection  = 7,
+
+                    // SRID-presence flag (EWKB)
+                    wkbSRID                = 0x20000000
+                }; // enum wkbGeometryType
+
+                /**
+                * Byte order marker in WKB geometry.
+                */
+                enum class wkb_byte_order_type : uint8_t {
+                    XDR = 0,         // Big Endian
+                    NDR = 1          // Little Endian
+                }; // enum class wkb_byte_order_type
+
+                std::string m_data;
+                uint32_t m_points {0};
+                wkb_type m_wkb_type;
+                out_type m_out_type;
+
+                size_t m_linestring_size_offset = 0;
+                size_t m_polygons = 0;
+                size_t m_rings = 0;
+                size_t m_multipolygon_size_offset = 0;
+                size_t m_polygon_size_offset = 0;
+                size_t m_ring_size_offset = 0;
+
+                size_t header(std::string& str, wkbGeometryType type, bool add_length) const {
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+                    str_push(str, wkb_byte_order_type::NDR);
+#else
+                    str_push(str, wkb_byte_order_type::XDR);
+#endif
+                    if (m_wkb_type == wkb_type::ewkb) {
+                        str_push(str, type | wkbSRID);
+                        str_push(str, srid);
+                    } else {
+                        str_push(str, type);
+                    }
+                    size_t offset = str.size();
+                    if (add_length) {
+                        str_push(str, static_cast<uint32_t>(0));
+                    }
+                    return offset;
+                }
+
+                void set_size(const size_t offset, const size_t size) {
+                    *reinterpret_cast<uint32_t*>(&m_data[offset]) = static_cast_with_assert<uint32_t>(size);
+                }
+
+            public:
+
+                typedef std::string point_type;
+                typedef std::string linestring_type;
+                typedef std::string polygon_type;
+                typedef std::string multipolygon_type;
+                typedef std::string ring_type;
+
+                explicit WKBFactoryImpl(wkb_type wtype = wkb_type::wkb, out_type otype = out_type::binary) :
+                    m_wkb_type(wtype),
+                    m_out_type(otype) {
+                }
+
+                /* Point */
+
+                point_type make_point(const osmium::geom::Coordinates& xy) const {
+                    std::string data;
+                    header(data, wkbPoint, false);
+                    str_push(data, xy.x);
+                    str_push(data, xy.y);
+
+                    if (m_out_type == out_type::hex) {
+                        return convert_to_hex(data);
+                    } else {
+                        return data;
+                    }
+                }
+
+                /* LineString */
+
+                void linestring_start() {
+                    m_data.clear();
+                    m_linestring_size_offset = header(m_data, wkbLineString, true);
+                }
+
+                void linestring_add_location(const osmium::geom::Coordinates& xy) {
+                    str_push(m_data, xy.x);
+                    str_push(m_data, xy.y);
+                }
+
+                linestring_type linestring_finish(size_t num_points) {
+                    set_size(m_linestring_size_offset, num_points);
+                    std::string data;
+
+                    using std::swap;
+                    swap(data, m_data);
+
+                    if (m_out_type == out_type::hex) {
+                        return convert_to_hex(data);
+                    } else {
+                        return data;
+                    }
+                }
+
+                /* MultiPolygon */
+
+                void multipolygon_start() {
+                    m_data.clear();
+                    m_polygons = 0;
+                    m_multipolygon_size_offset = header(m_data, wkbMultiPolygon, true);
+                }
+
+                void multipolygon_polygon_start() {
+                    ++m_polygons;
+                    m_rings = 0;
+                    m_polygon_size_offset = header(m_data, wkbPolygon, true);
+                }
+
+                void multipolygon_polygon_finish() {
+                    set_size(m_polygon_size_offset, m_rings);
+                }
+
+                void multipolygon_outer_ring_start() {
+                    ++m_rings;
+                    m_points = 0;
+                    m_ring_size_offset = m_data.size();
+                    str_push(m_data, static_cast<uint32_t>(0));
+                }
+
+                void multipolygon_outer_ring_finish() {
+                    set_size(m_ring_size_offset, m_points);
+                }
+
+                void multipolygon_inner_ring_start() {
+                    ++m_rings;
+                    m_points = 0;
+                    m_ring_size_offset = m_data.size();
+                    str_push(m_data, static_cast<uint32_t>(0));
+                }
+
+                void multipolygon_inner_ring_finish() {
+                    set_size(m_ring_size_offset, m_points);
+                }
+
+                void multipolygon_add_location(const osmium::geom::Coordinates& xy) {
+                    str_push(m_data, xy.x);
+                    str_push(m_data, xy.y);
+                    ++m_points;
+                }
+
+                multipolygon_type multipolygon_finish() {
+                    set_size(m_multipolygon_size_offset, m_polygons);
+                    std::string data;
+
+                    using std::swap;
+                    swap(data, m_data);
+
+                    if (m_out_type == out_type::hex) {
+                        return convert_to_hex(data);
+                    } else {
+                        return data;
+                    }
+                }
+
+            }; // class WKBFactoryImpl
+
+        } // namespace detail
+
+        template <typename TProjection = IdentityProjection>
+        using WKBFactory = GeometryFactory<osmium::geom::detail::WKBFactoryImpl, TProjection>;
+
+    } // namespace geom
+
+} // namespace osmium
+
+#endif // OSMIUM_GEOM_WKB_HPP

third_party/libosmium/include/osmium/geom/wkt.hpp

@@ -0,0 +1,156 @@
+#ifndef OSMIUM_GEOM_WKT_HPP
+#define OSMIUM_GEOM_WKT_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <string>
+#include <utility>
+
+#include <osmium/geom/coordinates.hpp>
+#include <osmium/geom/factory.hpp>
+
+namespace osmium {
+
+    namespace geom {
+
+        namespace detail {
+
+            class WKTFactoryImpl {
+
+                std::string m_str;
+                int m_precision;
+
+            public:
+
+                typedef std::string point_type;
+                typedef std::string linestring_type;
+                typedef std::string polygon_type;
+                typedef std::string multipolygon_type;
+                typedef std::string ring_type;
+
+                WKTFactoryImpl(int precision = 7) :
+                    m_precision(precision) {
+                }
+
+                /* Point */
+
+                point_type make_point(const osmium::geom::Coordinates& xy) const {
+                    std::string str {"POINT"};
+                    xy.append_to_string(str, '(', ' ', ')', m_precision);
+                    return str;
+                }
+
+                /* LineString */
+
+                void linestring_start() {
+                    m_str = "LINESTRING(";
+                }
+
+                void linestring_add_location(const osmium::geom::Coordinates& xy) {
+                    xy.append_to_string(m_str, ' ', m_precision);
+                    m_str += ',';
+                }
+
+                linestring_type linestring_finish(size_t /* num_points */) {
+                    assert(!m_str.empty());
+                    std::string str;
+
+                    using std::swap;
+                    swap(str, m_str);
+
+                    str.back() = ')';
+                    return str;
+                }
+
+                /* MultiPolygon */
+
+                void multipolygon_start() {
+                    m_str = "MULTIPOLYGON(";
+                }
+
+                void multipolygon_polygon_start() {
+                    m_str += '(';
+                }
+
+                void multipolygon_polygon_finish() {
+                    m_str += "),";
+                }
+
+                void multipolygon_outer_ring_start() {
+                    m_str += '(';
+                }
+
+                void multipolygon_outer_ring_finish() {
+                    assert(!m_str.empty());
+                    m_str.back() = ')';
+                }
+
+                void multipolygon_inner_ring_start() {
+                    m_str += ",(";
+                }
+
+                void multipolygon_inner_ring_finish() {
+                    assert(!m_str.empty());
+                    m_str.back() = ')';
+                }
+
+                void multipolygon_add_location(const osmium::geom::Coordinates& xy) {
+                    xy.append_to_string(m_str, ' ', m_precision);
+                    m_str += ',';
+                }
+
+                multipolygon_type multipolygon_finish() {
+                    assert(!m_str.empty());
+                    std::string str;
+
+                    using std::swap;
+                    swap(str, m_str);
+
+                    str.back() = ')';
+                    return str;
+                }
+
+            }; // class WKTFactoryImpl
+
+        } // namespace detail
+
+        template <typename TProjection = IdentityProjection>
+        using WKTFactory = GeometryFactory<osmium::geom::detail::WKTFactoryImpl, TProjection>;
+
+    } // namespace geom
+
+} // namespace osmium
+
+#endif // OSMIUM_GEOM_WKT_HPP

third_party/libosmium/include/osmium/handler.hpp

@@ -0,0 +1,94 @@
+#ifndef OSMIUM_HANDLER_HPP
+#define OSMIUM_HANDLER_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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/fwd.hpp>
+
+namespace osmium {
+
+    /**
+     * @brief Osmium handlers provide callbacks for OSM objects
+     */
+    namespace handler {
+
+        class Handler {
+
+        public:
+
+            void osm_object(const osmium::OSMObject&) const {
+            }
+
+            void node(const osmium::Node&) const {
+            }
+
+            void way(const osmium::Way&) const {
+            }
+
+            void relation(const osmium::Relation&) const {
+            }
+
+            void area(const osmium::Area&) const {
+            }
+
+            void changeset(const osmium::Changeset&) const {
+            }
+
+            void tag_list(const osmium::TagList&) const {
+            }
+
+            void way_node_list(const osmium::WayNodeList&) const {
+            }
+
+            void relation_member_list(const osmium::RelationMemberList&) const {
+            }
+
+            void outer_ring(const osmium::OuterRing&) const {
+            }
+
+            void inner_ring(const osmium::InnerRing&) const {
+            }
+
+            void changeset_discussion(const osmium::ChangesetDiscussion&) const {
+            }
+
+            void flush() const {
+            }
+
+        }; // class Handler
+
+    } // namespace handler
+
+} // namespace osmium
+
+#endif // OSMIUM_HANDLER_HPP

third_party/libosmium/include/osmium/handler/chain.hpp

@@ -0,0 +1,128 @@
+#ifndef OSMIUM_HANDLER_CHAIN_HPP
+#define OSMIUM_HANDLER_CHAIN_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <tuple>
+
+#include <osmium/handler.hpp>
+
+#define OSMIUM_CHAIN_HANDLER_CALL(_func_, _type_) \
+    template <int N, int SIZE, typename THandlers> \
+    struct call_ ## _func_ { \
+        void operator()(THandlers& handlers, osmium::_type_& object) { \
+            std::get<N>(handlers)._func_(object); \
+            call_ ## _func_<N+1, SIZE, THandlers>()(handlers, object); \
+        } \
+    }; \
+    template <int SIZE, typename THandlers> \
+    struct call_ ## _func_<SIZE, SIZE, THandlers> { \
+        void operator()(THandlers&, osmium::_type_&) {} \
+    };
+
+namespace osmium {
+
+    class Node;
+    class Way;
+    class Relation;
+    class Area;
+    class Changeset;
+
+    namespace handler {
+
+        /**
+         * This handler allows chaining of any number of handlers into a single
+         * handler.
+         */
+        template <typename... THandler>
+        class ChainHandler : public osmium::handler::Handler {
+
+            typedef std::tuple<THandler&...> handlers_type;
+            handlers_type m_handlers;
+
+            template <int N, int SIZE, typename THandlers>
+            struct call_flush {
+                void operator()(THandlers& handlers) {
+                    std::get<N>(handlers).flush();
+                    call_flush<N+1, SIZE, THandlers>()(handlers);
+                }
+            }; // struct call_flush
+
+            template <int SIZE, typename THandlers>
+            struct call_flush<SIZE, SIZE, THandlers> {
+                void operator()(THandlers&) {}
+            }; // struct call_flush
+
+            OSMIUM_CHAIN_HANDLER_CALL(node, Node)
+            OSMIUM_CHAIN_HANDLER_CALL(way, Way)
+            OSMIUM_CHAIN_HANDLER_CALL(relation, Relation)
+            OSMIUM_CHAIN_HANDLER_CALL(changeset, Changeset)
+            OSMIUM_CHAIN_HANDLER_CALL(area, Area)
+
+        public:
+
+            explicit ChainHandler(THandler&... handlers) :
+                m_handlers(handlers...) {
+            }
+
+            void node(osmium::Node& node) {
+                call_node<0, sizeof...(THandler), handlers_type>()(m_handlers, node);
+            }
+
+            void way(osmium::Way& way) {
+                call_way<0, sizeof...(THandler), handlers_type>()(m_handlers, way);
+            }
+
+            void relation(osmium::Relation& relation) {
+                call_relation<0, sizeof...(THandler), handlers_type>()(m_handlers, relation);
+            }
+
+            void changeset( osmium::Changeset& changeset) {
+                call_changeset<0, sizeof...(THandler), handlers_type>()(m_handlers, changeset);
+            }
+
+            void area(osmium::Area& area) {
+                call_area<0, sizeof...(THandler), handlers_type>()(m_handlers, area);
+            }
+
+            void flush() {
+                call_flush<0, sizeof...(THandler), handlers_type>()(m_handlers);
+            }
+
+        }; // class ChainHandler
+
+    } // namespace handler
+
+} // namespace osmium
+
+#endif // OSMIUM_HANDLER_CHAIN_HPP

third_party/libosmium/include/osmium/handler/check_order.hpp

@@ -0,0 +1,136 @@
+#ifndef OSMIUM_HANDLER_CHECK_ORDER_HPP
+#define OSMIUM_HANDLER_CHECK_ORDER_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <limits>
+#include <stdexcept>
+#include <string>
+
+#include <osmium/handler.hpp>
+#include <osmium/osm/node.hpp>
+#include <osmium/osm/relation.hpp>
+#include <osmium/osm/types.hpp>
+#include <osmium/osm/way.hpp>
+
+namespace osmium {
+
+    /**
+     * Exception thrown when a method in the CheckOrder class detects
+     * that the input is out of order.
+     */
+    struct out_of_order_error : public std::runtime_error {
+
+        out_of_order_error(const std::string& what) :
+            std::runtime_error(what) {
+        }
+
+        out_of_order_error(const char* what) :
+            std::runtime_error(what) {
+        }
+
+    }; // struct out_of_order_error
+
+    namespace handler {
+
+        /**
+         * Handler that can be used to check that an OSM file is ordered
+         * correctly. Ordered in this case refers to the usual order in OSM
+         * files: First nodes in the order of their IDs, then ways in the order
+         * of their IDs, then relations in the order or their IDs. IDs have to
+         * be unique for each type.
+         *
+         * To use this add a CheckOrder member variable to your handler and
+         * call the node(), way(), and relation() methods from your node(),
+         * way(), and relations() handlers, respectively. An out_of_order_error
+         * exception will be thrown when the input is not in order.
+         */
+        class CheckOrder : public osmium::handler::Handler {
+
+            osmium::object_id_type m_max_node_id     = std::numeric_limits<osmium::object_id_type>::min();
+            osmium::object_id_type m_max_way_id      = std::numeric_limits<osmium::object_id_type>::min();
+            osmium::object_id_type m_max_relation_id = std::numeric_limits<osmium::object_id_type>::min();
+
+        public:
+
+            void node(const osmium::Node& node) {
+                if (m_max_way_id > 0) {
+                    throw out_of_order_error("Found a node after a way.");
+                }
+                if (m_max_relation_id > 0) {
+                    throw out_of_order_error("Found a node after a relation.");
+                }
+
+                if (m_max_node_id >= node.id()) {
+                    throw out_of_order_error("Node IDs out of order.");
+                }
+                m_max_node_id = node.id();
+            }
+
+            void way(const osmium::Way& way) {
+                if (m_max_relation_id > 0) {
+                    throw out_of_order_error("Found a way after a relation.");
+                }
+
+                if (m_max_way_id >= way.id()) {
+                    throw out_of_order_error("Way IDs out of order.");
+                }
+                m_max_way_id = way.id();
+            }
+
+            void relation(const osmium::Relation& relation) {
+                if (m_max_relation_id >= relation.id()) {
+                    throw out_of_order_error("Relation IDs out of order.");
+                }
+                m_max_relation_id = relation.id();
+            }
+
+            osmium::object_id_type max_node_id() const noexcept {
+                return m_max_node_id;
+            }
+
+            osmium::object_id_type max_way_id() const noexcept {
+                return m_max_way_id;
+            }
+
+            osmium::object_id_type max_relation_id() const noexcept {
+                return m_max_relation_id;
+            }
+
+        }; // class CheckOrder
+
+    } // namespace handler
+
+} // namespace osmium
+
+#endif // OSMIUM_HANDLER_CHECK_ORDER_HPP

third_party/libosmium/include/osmium/handler/disk_store.hpp

@@ -0,0 +1,111 @@
+#ifndef OSMIUM_HANDLER_DISK_STORE_HPP
+#define OSMIUM_HANDLER_DISK_STORE_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <cstddef>
+
+#include <osmium/handler.hpp>
+#include <osmium/index/map.hpp>
+#include <osmium/io/detail/read_write.hpp>
+#include <osmium/memory/buffer.hpp>
+#include <osmium/memory/item_iterator.hpp>
+#include <osmium/osm/node.hpp>
+#include <osmium/osm/relation.hpp>
+#include <osmium/osm/types.hpp>
+#include <osmium/osm/way.hpp>
+#include <osmium/visitor.hpp>
+
+namespace osmium {
+
+    namespace handler {
+
+        /**
+         *
+         * Note: This handler will only work if either all object IDs are
+         *       positive or all object IDs are negative.
+         */
+        class DiskStore : public osmium::handler::Handler {
+
+            typedef osmium::index::map::Map<unsigned_object_id_type, size_t> offset_index_type;
+
+            size_t m_offset = 0;
+            int m_data_fd;
+
+            offset_index_type& m_node_index;
+            offset_index_type& m_way_index;
+            offset_index_type& m_relation_index;
+
+        public:
+
+            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_node_index(node_index),
+                m_way_index(way_index),
+                m_relation_index(relation_index) {
+            }
+
+            DiskStore(const DiskStore&) = delete;
+            DiskStore& operator=(const DiskStore&) = delete;
+
+            ~DiskStore() noexcept = default;
+
+            void node(const osmium::Node& node) {
+                m_node_index.set(node.positive_id(), m_offset);
+                m_offset += node.byte_size();
+            }
+
+            void way(const osmium::Way& way) {
+                m_way_index.set(way.positive_id(), m_offset);
+                m_offset += way.byte_size();
+            }
+
+            void relation(const osmium::Relation& relation) {
+                m_relation_index.set(relation.positive_id(), m_offset);
+                m_offset += relation.byte_size();
+            }
+
+            // XXX
+            void operator()(const osmium::memory::Buffer& buffer) {
+                osmium::io::detail::reliable_write(m_data_fd, buffer.data(), buffer.committed());
+
+                osmium::apply(buffer.begin(), buffer.end(), *this);
+            }
+
+        }; // class DiskStore
+
+    } // namespace handler
+
+} // namespace osmium
+
+#endif // OSMIUM_HANDLER_DISK_STORE_HPP

third_party/libosmium/include/osmium/handler/dump.hpp

@@ -0,0 +1,294 @@
+#ifndef OSMIUM_HANDLER_DUMP_HPP
+#define OSMIUM_HANDLER_DUMP_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <iomanip>
+#include <iostream>
+#include <string>
+
+#include <osmium/handler.hpp>
+#include <osmium/memory/collection.hpp>
+#include <osmium/memory/item.hpp>
+#include <osmium/osm/area.hpp>
+#include <osmium/osm/box.hpp>
+#include <osmium/osm/changeset.hpp>
+#include <osmium/osm/item_type.hpp>
+#include <osmium/osm/location.hpp>
+#include <osmium/osm/node.hpp>
+#include <osmium/osm/node_ref.hpp>
+#include <osmium/osm/object.hpp>
+#include <osmium/osm/relation.hpp>
+#include <osmium/osm/tag.hpp>
+#include <osmium/osm/timestamp.hpp>
+#include <osmium/osm/way.hpp>
+#include <osmium/visitor.hpp>
+
+namespace osmium {
+
+    namespace handler {
+
+        class Dump : public osmium::handler::Handler {
+
+            std::ostream* m_out;
+            bool m_with_size;
+            std::string m_prefix;
+
+            void print_title(const char* title, const osmium::memory::Item& item) {
+                *m_out << m_prefix
+                       << title
+                       << ":";
+
+                if (m_with_size) {
+                    *m_out << " ["
+                           << item.byte_size()
+                           << "]";
+                }
+
+                *m_out << "\n";
+            }
+
+            void print_meta(const osmium::OSMObject& object) {
+                *m_out << m_prefix
+                       << "  id="
+                       << object.id()
+                       << "\n";
+                *m_out << m_prefix
+                       << "  version="
+                       << object.version()
+                       << "\n";
+                *m_out << m_prefix
+                       << "  uid="
+                       << object.uid()
+                       << "\n";
+                *m_out << m_prefix
+                       << "  user=|"
+                       << object.user()
+                       << "|\n";
+                *m_out << m_prefix
+                       << "  changeset="
+                       << object.changeset()
+                       << "\n";
+                *m_out << m_prefix
+                       << "  timestamp="
+                       << object.timestamp().to_iso()
+                       << "\n";
+                *m_out << m_prefix
+                       << "  visible="
+                       << (object.visible() ? "yes" : "no")
+                       << "\n";
+
+                Dump dump(*m_out, m_with_size, m_prefix + "  ");
+                osmium::apply(object.cbegin(), object.cend(), dump);
+            }
+
+            void print_location(const osmium::Node& node) {
+                const osmium::Location& location = node.location();
+
+                if (location) {
+                    *m_out << m_prefix
+                           << "  lon="
+                           << std::fixed
+                           << std::setprecision(7)
+                           << location.lon_without_check()
+                           << "\n";
+                    *m_out << m_prefix
+                           << "  lat="
+                           << location.lat_without_check()
+                           << "\n";
+                } else {
+                    *m_out << m_prefix
+                           << "  lon=\n"
+                           << m_prefix
+                           << "  lat=\n";
+                }
+            }
+
+        public:
+
+            explicit Dump(std::ostream& out, bool with_size = true, const std::string& prefix = "") :
+                m_out(&out),
+                m_with_size(with_size),
+                m_prefix(prefix) {
+            }
+
+            void tag_list(const osmium::TagList& tags) {
+                print_title("TAGS", tags);
+                for (const auto& tag : tags) {
+                    *m_out << m_prefix
+                           << "  k=|"
+                           << tag.key()
+                           << "| v=|"
+                           << tag.value()
+                           << "|"
+                           << "\n";
+                }
+            }
+
+            void way_node_list(const osmium::WayNodeList& wnl) {
+                print_title("NODES", wnl);
+                for (const auto& node_ref : wnl) {
+                    *m_out << m_prefix
+                           << "  ref="
+                           << node_ref.ref();
+                    if (node_ref.location()) {
+                        *m_out << " pos="
+                               << node_ref.location();
+                    }
+                    *m_out << "\n";
+                }
+            }
+
+            void relation_member_list(const osmium::RelationMemberList& rml) {
+                print_title("MEMBERS", rml);
+                for (const auto& member : rml) {
+                    *m_out << m_prefix
+                           << "  type="
+                           << item_type_to_name(member.type())
+                           << " ref="
+                           << member.ref()
+                           << " role=|"
+                           << member.role()
+                           << "|\n";
+                    if (member.full_member()) {
+                        Dump dump(*m_out, m_with_size, m_prefix + "  | ");
+                        osmium::apply_item(member.get_object(), dump);
+                    }
+                }
+            }
+
+            void outer_ring(const osmium::OuterRing& ring) {
+                print_title("OUTER RING", ring);
+                for (const auto& node_ref : ring) {
+                    *m_out << m_prefix
+                           << "  ref="
+                           << node_ref.ref();
+                    if (node_ref.location()) {
+                        *m_out << " pos="
+                               << node_ref.location();
+                    }
+                    *m_out << "\n";
+                }
+            }
+
+            void inner_ring(const osmium::InnerRing& ring) {
+                print_title("INNER RING", ring);
+                for (const auto& node_ref : ring) {
+                    *m_out << m_prefix
+                           << "  ref="
+                           << node_ref.ref();
+                    if (node_ref.location()) {
+                        *m_out << " pos="
+                               << node_ref.location();
+                    }
+                    *m_out << "\n";
+                }
+            }
+
+            void node(const osmium::Node& node) {
+                print_title("NODE", node);
+                print_meta(node);
+                print_location(node);
+            }
+
+            void way(const osmium::Way& way) {
+                print_title("WAY", way);
+                print_meta(way);
+            }
+
+            void relation(const osmium::Relation& relation) {
+                print_title("RELATION", relation);
+                print_meta(relation);
+            }
+
+            void area(const osmium::Area& area) {
+                print_title("AREA", area);
+                print_meta(area);
+            }
+
+            void changeset(const osmium::Changeset& changeset) {
+                print_title("CHANGESET", changeset);
+                *m_out << m_prefix
+                       << "  id="
+                       << changeset.id()
+                       << "\n";
+                *m_out << m_prefix
+                       << "  num_changes="
+                       << changeset.num_changes()
+                       << "\n";
+                *m_out << m_prefix
+                       << "  uid="
+                       << changeset.uid()
+                       << "\n";
+                *m_out << m_prefix
+                       << "  user=|"
+                       << changeset.user()
+                       << "|\n";
+                *m_out << m_prefix
+                       << "  created_at="
+                       << changeset.created_at().to_iso()
+                       << "\n";
+                *m_out << m_prefix
+                       << "  closed_at="
+                       << changeset.closed_at().to_iso()
+                       << "\n";
+                *m_out << m_prefix
+                       << "  bounds=";
+
+                if (changeset.bounds()) {
+                    *m_out << '('
+                           << changeset.bounds().bottom_left().lon_without_check()
+                           << ','
+                           << changeset.bounds().bottom_left().lat_without_check()
+                           << ','
+                           << changeset.bounds().top_right().lon_without_check()
+                           << ','
+                           << changeset.bounds().top_right().lat_without_check()
+                           << ')';
+                } else {
+                    *m_out << "(undefined)";
+                }
+
+                *m_out << "\n";
+
+                Dump dump(*m_out, m_with_size, m_prefix + "  ");
+                osmium::apply(changeset.cbegin(), changeset.cend(), dump);
+            }
+
+        }; // class Dump
+
+    } // namespace handler
+
+} // namespace osmium
+
+#endif // OSMIUM_HANDLER_DUMP_HPP

third_party/libosmium/include/osmium/handler/node_locations_for_ways.hpp

@@ -0,0 +1,180 @@
+#ifndef OSMIUM_HANDLER_NODE_LOCATIONS_FOR_WAYS_HPP
+#define OSMIUM_HANDLER_NODE_LOCATIONS_FOR_WAYS_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <type_traits>
+
+#include <osmium/handler.hpp>
+#include <osmium/index/index.hpp>
+#include <osmium/index/map/dummy.hpp>
+#include <osmium/osm/location.hpp>
+#include <osmium/osm/node.hpp>
+#include <osmium/osm/node_ref.hpp>
+#include <osmium/osm/types.hpp>
+#include <osmium/osm/way.hpp>
+
+#include <osmium/index/node_locations_map.hpp>
+
+namespace osmium {
+
+    namespace handler {
+
+        typedef osmium::index::map::Dummy<osmium::unsigned_object_id_type, osmium::Location> dummy_type;
+
+        /**
+         * Handler to retrieve locations from nodes and add them to ways.
+         *
+         * @tparam TStoragePosIDs Class that handles the actual storage of the node locations
+         *                        (for positive IDs). It must support the set(id, value) and
+         *                        get(id) methods.
+         * @tparam TStorageNegIDs Same but for negative IDs.
+         */
+        template <typename TStoragePosIDs, typename TStorageNegIDs = dummy_type>
+        class NodeLocationsForWays : public osmium::handler::Handler {
+
+            static_assert(std::is_base_of<osmium::index::map::Map<osmium::unsigned_object_id_type, osmium::Location>, TStoragePosIDs>::value, "Index class must be derived from osmium::index::map::Map<osmium::unsigned_object_id_type, osmium::Location>");
+
+            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>");
+
+        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).
+            TStoragePosIDs& m_storage_pos;
+
+            /// Object that handles the actual storage of the node locations (with negative IDs).
+            TStorageNegIDs& m_storage_neg;
+
+            bool m_ignore_errors {false};
+
+            bool m_must_sort {false};
+
+            // It is okay to have this static dummy instance, even when using several threads,
+            // because it is read-only.
+            static dummy_type& get_dummy() {
+                static dummy_type instance;
+                return instance;
+            }
+
+        public:
+
+            explicit NodeLocationsForWays(TStoragePosIDs& storage_pos,
+                                          TStorageNegIDs& storage_neg = get_dummy()) :
+                m_storage_pos(storage_pos),
+                m_storage_neg(storage_neg) {
+            }
+
+            NodeLocationsForWays(const NodeLocationsForWays&) = delete;
+            NodeLocationsForWays& operator=(const NodeLocationsForWays&) = delete;
+
+            NodeLocationsForWays(NodeLocationsForWays&&) = default;
+            NodeLocationsForWays& operator=(NodeLocationsForWays&&) = default;
+
+            ~NodeLocationsForWays() noexcept = default;
+
+            void ignore_errors() {
+                m_ignore_errors = true;
+            }
+
+            /**
+             * Store the location of the node in the storage.
+             */
+            void node(const osmium::Node& node) {
+                m_must_sort = true;
+                const osmium::object_id_type id = node.id();
+                if (id >= 0) {
+                    m_storage_pos.set(static_cast<osmium::unsigned_object_id_type>( id), node.location());
+                } else {
+                    m_storage_neg.set(static_cast<osmium::unsigned_object_id_type>(-id), node.location());
+                }
+            }
+
+            /**
+             * Get location of node with given id.
+             */
+            osmium::Location get_node_location(const osmium::object_id_type id) const {
+                if (id >= 0) {
+                    return m_storage_pos.get(static_cast<osmium::unsigned_object_id_type>( id));
+                } else {
+                    return m_storage_neg.get(static_cast<osmium::unsigned_object_id_type>(-id));
+                }
+            }
+
+            /**
+             * Retrieve locations of all nodes in the way from storage and add
+             * them to the way object.
+             */
+            void way(osmium::Way& way) {
+                if (m_must_sort) {
+                    m_storage_pos.sort();
+                    m_storage_neg.sort();
+                    m_must_sort = false;
+                }
+                bool error = false;
+                for (auto& node_ref : way.nodes()) {
+                    try {
+                        node_ref.set_location(get_node_location(node_ref.ref()));
+                        if (!node_ref.location()) {
+                            error = true;
+                        }
+                    } catch (osmium::not_found&) {
+                        error = true;
+                    }
+                }
+                if (error && !m_ignore_errors) {
+                    throw osmium::not_found("location for one or more nodes not found in node location index");
+                }
+            }
+
+            /**
+             * Call clear on the location indexes. Makes the
+             * NodeLocationsForWays handler unusable. Used to explicitly free
+             * memory if thats needed.
+             */
+            void clear() {
+                m_storage_pos.clear();
+                m_storage_neg.clear();
+            }
+
+        }; // class NodeLocationsForWays
+
+    } // namespace handler
+
+} // namespace osmium
+
+#endif // OSMIUM_HANDLER_NODE_LOCATIONS_FOR_WAYS_HPP

third_party/libosmium/include/osmium/handler/object_relations.hpp

@@ -0,0 +1,106 @@
+#ifndef OSMIUM_HANDLER_OBJECT_RELATIONS_HPP
+#define OSMIUM_HANDLER_OBJECT_RELATIONS_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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.hpp>
+#include <osmium/index/multimap.hpp>
+#include <osmium/osm/node_ref.hpp>
+#include <osmium/osm/item_type.hpp>
+#include <osmium/osm/relation.hpp>
+#include <osmium/osm/types.hpp>
+#include <osmium/osm/way.hpp>
+
+namespace osmium {
+
+    namespace handler {
+
+        /**
+         *
+         * Note: This handler will only work if either all object IDs are
+         *       positive or all object IDs are negative.
+         */
+        class ObjectRelations : public osmium::handler::Handler {
+
+            typedef osmium::index::multimap::Multimap<unsigned_object_id_type, unsigned_object_id_type> index_type;
+
+            index_type& m_index_n2w;
+            index_type& m_index_n2r;
+            index_type& m_index_w2r;
+            index_type& m_index_r2r;
+
+        public:
+
+            explicit ObjectRelations(index_type& n2w, index_type& n2r, index_type& w2r, index_type& r2r) :
+                m_index_n2w(n2w),
+                m_index_n2r(n2r),
+                m_index_w2r(w2r),
+                m_index_r2r(r2r) {
+            }
+
+            ObjectRelations(const ObjectRelations&) = delete;
+            ObjectRelations& operator=(const ObjectRelations&) = delete;
+
+            ~ObjectRelations() noexcept = default;
+
+            void way(const osmium::Way& way) {
+                for (const auto& node_ref : way.nodes()) {
+                    m_index_n2w.set(node_ref.positive_ref(), way.positive_id());
+                }
+            }
+
+            void relation(const osmium::Relation& relation) {
+                for (const auto& member : relation.members()) {
+                    switch (member.type()) {
+                        case osmium::item_type::node:
+                            m_index_n2r.set(member.positive_ref(), relation.positive_id());
+                            break;
+                        case osmium::item_type::way:
+                            m_index_w2r.set(member.positive_ref(), relation.positive_id());
+                            break;
+                        case osmium::item_type::relation:
+                            m_index_r2r.set(member.positive_ref(), relation.positive_id());
+                            break;
+                        default:
+                            break;
+                    }
+                }
+            }
+
+        }; // class ObjectRelations
+
+    } // namespace handler
+
+} // namespace osmium
+
+#endif // OSMIUM_HANDLER_OBJECT_RELATIONS_HPP

third_party/libosmium/include/osmium/index/bool_vector.hpp

@@ -0,0 +1,85 @@
+#ifndef OSMIUM_INDEX_BOOL_VECTOR_HPP
+#define OSMIUM_INDEX_BOOL_VECTOR_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <type_traits>
+#include <vector>
+
+namespace osmium {
+
+    namespace index {
+
+        /**
+         * Index storing one bit for each Id. The index automatically scales
+         * with the Ids stored. Default value is 'false'. Storage uses
+         * std::vector<bool> and needs a minimum of memory if the Ids are
+         * dense.
+         */
+        template <typename T>
+        class BoolVector {
+
+            static_assert(std::is_unsigned<T>::value, "Needs unsigned type");
+
+            std::vector<bool> m_bits;
+
+        public:
+
+            BoolVector() = default;
+
+            BoolVector(const BoolVector&) = default;
+            BoolVector(BoolVector&&) = default;
+            BoolVector& operator=(const BoolVector&) = default;
+            BoolVector& operator=(BoolVector&&) = default;
+
+            ~BoolVector() noexcept = default;
+
+            void set(T id, bool value = true) {
+                if (m_bits.size() <= id) {
+                    m_bits.resize(id + 1024 * 1024);
+                }
+
+                m_bits[id] = value;
+            }
+
+            bool get(T id) const {
+                return id < m_bits.size() && m_bits[id];
+            }
+
+        }; // class BoolVector
+
+    } // namespace index
+
+} // namespace osmium
+
+#endif // OSMIUM_INDEX_BOOL_VECTOR_HPP

third_party/libosmium/include/osmium/index/detail/create_map_with_fd.hpp

@@ -0,0 +1,70 @@
+#ifndef OSMIUM_INDEX_DETAIL_CREATE_MAP_WITH_FD_HPP
+#define OSMIUM_INDEX_DETAIL_CREATE_MAP_WITH_FD_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <cerrno>
+#include <cstring>
+#include <fcntl.h>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace osmium {
+
+    namespace index {
+
+        namespace detail {
+
+            template <typename T>
+            inline T* create_map_with_fd(const std::vector<std::string>& config) {
+                if (config.size() == 1) {
+                    return new T();
+                }
+                assert(config.size() > 1);
+                const std::string& filename = config[1];
+                int fd = ::open(filename.c_str(), O_CREAT | O_RDWR, 0644);
+                if (fd == -1) {
+                    throw std::runtime_error(std::string("can't open file '") + filename + "': " + strerror(errno));
+                }
+                return new T(fd);
+            }
+
+        } // namespace detail
+
+    } // namespace index
+
+} // namespace osmium
+
+#endif // OSMIUM_INDEX_DETAIL_CREATE_MAP_WITH_FD_HPP

third_party/libosmium/include/osmium/index/detail/mmap_vector_anon.hpp

@@ -0,0 +1,67 @@
+#ifndef OSMIUM_INDEX_DETAIL_MMAP_VECTOR_ANON_HPP
+#define OSMIUM_INDEX_DETAIL_MMAP_VECTOR_ANON_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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.
+
+*/
+
+#ifdef __linux__
+
+#include <osmium/index/detail/mmap_vector_base.hpp>
+
+namespace osmium {
+
+    namespace detail {
+
+        /**
+         * This class looks and behaves like STL vector, but uses mmap
+         * internally.
+         */
+        template <typename T>
+        class mmap_vector_anon : public mmap_vector_base<T> {
+
+        public:
+
+            mmap_vector_anon() :
+                mmap_vector_base<T>() {
+            }
+
+            ~mmap_vector_anon() noexcept = default;
+
+        }; // class mmap_vector_anon
+
+    } // namespace detail
+
+} // namespace osmium
+
+#endif // __linux__
+
+#endif // OSMIUM_INDEX_DETAIL_MMAP_VECTOR_ANON_HPP

third_party/libosmium/include/osmium/index/detail/mmap_vector_base.hpp

@@ -0,0 +1,180 @@
+#ifndef OSMIUM_INDEX_DETAIL_MMAP_VECTOR_BASE_HPP
+#define OSMIUM_INDEX_DETAIL_MMAP_VECTOR_BASE_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <cstddef>
+#include <new> // IWYU pragma: keep
+#include <stdexcept>
+
+#include <osmium/util/memory_mapping.hpp>
+
+namespace osmium {
+
+    namespace detail {
+
+        constexpr size_t mmap_vector_size_increment = 1024 * 1024;
+
+        /**
+         * This is a base class for implementing classes that look like
+         * STL vector but use mmap internally. Do not use this class itself,
+         * use the derived classes mmap_vector_anon or mmap_vector_file.
+         */
+        template <typename T>
+        class mmap_vector_base {
+
+        protected:
+
+            size_t m_size;
+            osmium::util::TypedMemoryMapping<T> m_mapping;
+
+        public:
+
+            mmap_vector_base(int fd, size_t capacity, size_t size = 0) :
+                m_size(size),
+                m_mapping(capacity, osmium::util::MemoryMapping::mapping_mode::write_shared, fd) {
+            }
+
+            explicit mmap_vector_base(size_t capacity = mmap_vector_size_increment) :
+                m_size(0),
+                m_mapping(capacity) {
+            }
+
+            ~mmap_vector_base() noexcept = default;
+
+            typedef T value_type;
+            typedef T& reference;
+            typedef const T& const_reference;
+            typedef T* pointer;
+            typedef const T* const_pointer;
+            typedef T* iterator;
+            typedef const T* const_iterator;
+
+            void close() {
+                m_mapping.unmap();
+            }
+
+            size_t capacity() const noexcept {
+                return m_mapping.size();
+            }
+
+            size_t size() const noexcept {
+                return m_size;
+            }
+
+            bool empty() const noexcept {
+                return m_size == 0;
+            }
+
+            const T* data() const {
+                return m_mapping.begin();
+            }
+
+            T* data() {
+                return m_mapping.begin();
+            }
+
+            T& operator[](size_t n) {
+                return data()[n];
+            }
+
+            T at(size_t n) const {
+                if (n >= m_size) {
+                    throw std::out_of_range("out of range");
+                }
+                return data()[n];
+            }
+
+            void clear() noexcept {
+                m_size = 0;
+            }
+
+            void shrink_to_fit() {
+                // XXX do something here
+            }
+
+            void push_back(const T& value) {
+                if (m_size >= capacity()) {
+                    resize(m_size+1);
+                }
+                data()[m_size] = value;
+                ++m_size;
+            }
+
+            void reserve(size_t new_capacity) {
+                if (new_capacity > capacity()) {
+                    m_mapping.resize(new_capacity);
+                }
+            }
+
+            void resize(size_t new_size) {
+                if (new_size > capacity()) {
+                    reserve(new_size + osmium::detail::mmap_vector_size_increment);
+                }
+                if (new_size > size()) {
+                    new (data() + size()) T[new_size - size()];
+                }
+                m_size = new_size;
+            }
+
+            iterator begin() noexcept {
+                return data();
+            }
+
+            iterator end() noexcept {
+                return data() + m_size;
+            }
+
+            const_iterator begin() const noexcept {
+                return data();
+            }
+
+            const_iterator end() const noexcept {
+                return data() + m_size;
+            }
+
+            const_iterator cbegin() const noexcept {
+                return data();
+            }
+
+            const_iterator cend() const noexcept {
+                return data() + m_size;
+            }
+
+        }; // class mmap_vector_base
+
+    } // namespace detail
+
+} // namespace osmium
+
+#endif // OSMIUM_INDEX_DETAIL_MMAP_VECTOR_BASE_HPP

third_party/libosmium/include/osmium/index/detail/mmap_vector_file.hpp

@@ -0,0 +1,74 @@
+#ifndef OSMIUM_INDEX_DETAIL_MMAP_VECTOR_FILE_HPP
+#define OSMIUM_INDEX_DETAIL_MMAP_VECTOR_FILE_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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/index/detail/mmap_vector_base.hpp>
+#include <osmium/index/detail/tmpfile.hpp>
+#include <osmium/util/file.hpp>
+
+namespace osmium {
+
+    namespace detail {
+
+        /**
+         * This class looks and behaves like STL vector, but mmap's a file
+         * internally.
+         */
+        template <typename T>
+        class mmap_vector_file : public mmap_vector_base<T> {
+
+        public:
+
+            mmap_vector_file() :
+                mmap_vector_base<T>(
+                    osmium::detail::create_tmp_file(),
+                    osmium::detail::mmap_vector_size_increment) {
+            }
+
+            explicit mmap_vector_file(int fd) :
+                mmap_vector_base<T>(
+                    fd,
+                    osmium::util::file_size(fd) / sizeof(T),
+                    osmium::util::file_size(fd) / sizeof(T)) {
+            }
+
+            ~mmap_vector_file() noexcept = default;
+
+        }; // class mmap_vector_file
+
+    } // namespace detail
+
+} // namespace osmium
+
+#endif // OSMIUM_INDEX_DETAIL_MMAP_VECTOR_FILE_HPP

third_party/libosmium/include/osmium/index/detail/tmpfile.hpp

@@ -0,0 +1,62 @@
+#ifndef OSMIUM_INDEX_DETAIL_TMPFILE_HPP
+#define OSMIUM_INDEX_DETAIL_TMPFILE_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <cerrno>
+#include <cstdio>
+#include <system_error>
+
+namespace osmium {
+
+    namespace detail {
+
+        /**
+         * Create and open a temporary file. It is removed after opening.
+         *
+         * @returns File descriptor of temporary file.
+         * @throws std::system_error if something went wrong.
+         */
+        inline int create_tmp_file() {
+            FILE* file = ::tmpfile();
+            if (!file) {
+                throw std::system_error(errno, std::system_category(), "tempfile failed");
+            }
+            return fileno(file);
+        }
+
+    } // namespace detail
+
+} // namespace osmium
+
+#endif // OSMIUM_INDEX_DETAIL_TMPFILE_HPP

third_party/libosmium/include/osmium/index/detail/vector_map.hpp

@@ -0,0 +1,246 @@
+#ifndef OSMIUM_INDEX_DETAIL_VECTOR_MAP_HPP
+#define OSMIUM_INDEX_DETAIL_VECTOR_MAP_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <algorithm>
+#include <cstddef>
+#include <stdexcept>
+#include <utility>
+
+#include <osmium/index/index.hpp>
+#include <osmium/index/map.hpp>
+#include <osmium/io/detail/read_write.hpp>
+
+namespace osmium {
+
+    namespace index {
+
+        namespace map {
+
+            template <typename TVector, typename TId, typename TValue>
+            class VectorBasedDenseMap : public Map<TId, TValue> {
+
+                TVector m_vector;
+
+            public:
+
+                typedef TValue element_type;
+                typedef TVector vector_type;
+                typedef typename vector_type::iterator iterator;
+                typedef typename vector_type::const_iterator const_iterator;
+
+                VectorBasedDenseMap() :
+                    m_vector() {
+                }
+
+                explicit VectorBasedDenseMap(int fd) :
+                    m_vector(fd) {
+                }
+
+                ~VectorBasedDenseMap() noexcept final = default;
+
+                void reserve(const size_t size) final {
+                    m_vector.reserve(size);
+                }
+
+                void set(const TId id, const TValue value) final {
+                    if (size() <= id) {
+                        m_vector.resize(id+1);
+                    }
+                    m_vector[id] = value;
+                }
+
+                const TValue get(const TId id) const final {
+                    try {
+                        const TValue& value = m_vector.at(id);
+                        if (value == osmium::index::empty_value<TValue>()) {
+                            not_found_error(id);
+                        }
+                        return value;
+                    } catch (std::out_of_range&) {
+                        not_found_error(id);
+                    }
+                }
+
+                size_t size() const final {
+                    return m_vector.size();
+                }
+
+                size_t byte_size() const {
+                    return m_vector.size() * sizeof(element_type);
+                }
+
+                size_t used_memory() const final {
+                    return sizeof(TValue) * size();
+                }
+
+                void clear() final {
+                    m_vector.clear();
+                    m_vector.shrink_to_fit();
+                }
+
+                void dump_as_array(const int fd) final {
+                    osmium::io::detail::reliable_write(fd, reinterpret_cast<const char*>(m_vector.data()), byte_size());
+                }
+
+                iterator begin() {
+                    return m_vector.begin();
+                }
+
+                iterator end() {
+                    return m_vector.end();
+                }
+
+                const_iterator cbegin() const {
+                    return m_vector.cbegin();
+                }
+
+                const_iterator cend() const {
+                    return m_vector.cend();
+                }
+
+                const_iterator begin() const {
+                    return m_vector.cbegin();
+                }
+
+                const_iterator end() const {
+                    return m_vector.cend();
+                }
+
+            }; // class VectorBasedDenseMap
+
+
+            template <typename TId, typename TValue, template<typename...> class TVector>
+            class VectorBasedSparseMap : public Map<TId, TValue> {
+
+            public:
+
+                typedef typename std::pair<TId, TValue> element_type;
+                typedef TVector<element_type> vector_type;
+                typedef typename vector_type::iterator iterator;
+                typedef typename vector_type::const_iterator const_iterator;
+
+            private:
+
+                vector_type m_vector;
+
+            public:
+
+                VectorBasedSparseMap() :
+                    m_vector() {
+                }
+
+                explicit VectorBasedSparseMap(int fd) :
+                    m_vector(fd) {
+                }
+
+                ~VectorBasedSparseMap() final = default;
+
+                void set(const TId id, const TValue value) final {
+                    m_vector.push_back(element_type(id, value));
+                }
+
+                const TValue get(const TId id) const final {
+                    const element_type element {
+                        id,
+                        osmium::index::empty_value<TValue>()
+                    };
+                    const auto result = std::lower_bound(m_vector.begin(), m_vector.end(), element, [](const element_type& a, const element_type& b) {
+                        return a.first < b.first;
+                    });
+                    if (result == m_vector.end() || result->first != id) {
+                        not_found_error(id);
+                    } else {
+                        return result->second;
+                    }
+                }
+
+                size_t size() const final {
+                    return m_vector.size();
+                }
+
+                size_t byte_size() const {
+                    return m_vector.size() * sizeof(element_type);
+                }
+
+                size_t used_memory() const final {
+                    return sizeof(element_type) * size();
+                }
+
+                void clear() final {
+                    m_vector.clear();
+                    m_vector.shrink_to_fit();
+                }
+
+                void sort() final {
+                    std::sort(m_vector.begin(), m_vector.end());
+                }
+
+                void dump_as_list(const int fd) final {
+                    osmium::io::detail::reliable_write(fd, reinterpret_cast<const char*>(m_vector.data()), byte_size());
+                }
+
+                iterator begin() {
+                    return m_vector.begin();
+                }
+
+                iterator end() {
+                    return m_vector.end();
+                }
+
+                const_iterator cbegin() const {
+                    return m_vector.cbegin();
+                }
+
+                const_iterator cend() const {
+                    return m_vector.cend();
+                }
+
+                const_iterator begin() const {
+                    return m_vector.cbegin();
+                }
+
+                const_iterator end() const {
+                    return m_vector.cend();
+                }
+
+            }; // class VectorBasedSparseMap
+
+        } // namespace map
+
+    } // namespace index
+
+} // namespace osmium
+
+#endif // OSMIUM_INDEX_DETAIL_VECTOR_MAP_HPP

third_party/libosmium/include/osmium/index/detail/vector_multimap.hpp

@@ -0,0 +1,186 @@
+#ifndef OSMIUM_INDEX_DETAIL_VECTOR_MULTIMAP_HPP
+#define OSMIUM_INDEX_DETAIL_VECTOR_MULTIMAP_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <algorithm>
+#include <cstddef>
+#include <utility>
+
+#include <osmium/index/index.hpp>
+#include <osmium/index/multimap.hpp>
+#include <osmium/io/detail/read_write.hpp>
+
+namespace osmium {
+
+    namespace index {
+
+        namespace multimap {
+
+            template <typename TId, typename TValue, template<typename...> class TVector>
+            class VectorBasedSparseMultimap : public Multimap<TId, TValue> {
+
+            public:
+
+                typedef typename std::pair<TId, TValue> element_type;
+                typedef TVector<element_type> vector_type;
+                typedef typename vector_type::iterator iterator;
+                typedef typename vector_type::const_iterator const_iterator;
+
+            private:
+
+                vector_type m_vector;
+
+                static bool is_removed(element_type& element) {
+                    return element.second == osmium::index::empty_value<TValue>();
+                }
+
+            public:
+
+                VectorBasedSparseMultimap() :
+                    m_vector() {
+                }
+
+                explicit VectorBasedSparseMultimap(int fd) :
+                    m_vector(fd) {
+                }
+
+                ~VectorBasedSparseMultimap() noexcept final = default;
+
+                void set(const TId id, const TValue value) final {
+                    m_vector.push_back(element_type(id, value));
+                }
+
+                void unsorted_set(const TId id, const TValue value) {
+                    m_vector.push_back(element_type(id, value));
+                }
+
+                std::pair<iterator, iterator> get_all(const TId id) {
+                    const element_type element {
+                        id,
+                        osmium::index::empty_value<TValue>()
+                    };
+                    return std::equal_range(m_vector.begin(), m_vector.end(), element, [](const element_type& a, const element_type& b) {
+                        return a.first < b.first;
+                    });
+                }
+
+                std::pair<const_iterator, const_iterator> get_all(const TId id) const {
+                    const element_type element {
+                        id,
+                        osmium::index::empty_value<TValue>()
+                    };
+                    return std::equal_range(m_vector.cbegin(), m_vector.cend(), element, [](const element_type& a, const element_type& b) {
+                        return a.first < b.first;
+                    });
+                }
+
+                size_t size() const final {
+                    return m_vector.size();
+                }
+
+                size_t byte_size() const {
+                    return m_vector.size() * sizeof(element_type);
+                }
+
+                size_t used_memory() const final {
+                    return sizeof(element_type) * size();
+                }
+
+                void clear() final {
+                    m_vector.clear();
+                    m_vector.shrink_to_fit();
+                }
+
+                void sort() final {
+                    std::sort(m_vector.begin(), m_vector.end());
+                }
+
+                void remove(const TId id, const TValue value) {
+                    auto r = get_all(id);
+                    for (auto it = r.first; it != r.second; ++it) {
+                        if (it->second == value) {
+                            it->second = 0;
+                            return;
+                        }
+                    }
+                }
+
+                void consolidate() {
+                    std::sort(m_vector.begin(), m_vector.end());
+                }
+
+                void erase_removed() {
+                    m_vector.erase(
+                        std::remove_if(m_vector.begin(), m_vector.end(), is_removed),
+                        m_vector.end()
+                    );
+                }
+
+                void dump_as_list(const int fd) final {
+                    osmium::io::detail::reliable_write(fd, reinterpret_cast<const char*>(m_vector.data()), byte_size());
+                }
+
+                iterator begin() {
+                    return m_vector.begin();
+                }
+
+                iterator end() {
+                    return m_vector.end();
+                }
+
+                const_iterator cbegin() const {
+                    return m_vector.cbegin();
+                }
+
+                const_iterator cend() const {
+                    return m_vector.cend();
+                }
+
+                const_iterator begin() const {
+                    return m_vector.cbegin();
+                }
+
+                const_iterator end() const {
+                    return m_vector.cend();
+                }
+
+            }; // class VectorBasedSparseMultimap
+
+        } // namespace multimap
+
+    } // namespace index
+
+} // namespace osmium
+
+#endif // OSMIUM_INDEX_DETAIL_VECTOR_MULTIMAP_HPP

third_party/libosmium/include/osmium/index/index.hpp

@@ -0,0 +1,100 @@
+#ifndef OSMIUM_INDEX_INDEX_HPP
+#define OSMIUM_INDEX_INDEX_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <cstddef>
+#include <limits>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+
+#include <osmium/util/compatibility.hpp>
+
+namespace osmium {
+
+    /**
+     * Exception signaling that an element could not be
+     * found in an index.
+     */
+    struct not_found : public std::runtime_error {
+
+        not_found(const std::string& what) :
+            std::runtime_error(what) {
+        }
+
+        not_found(const char* what) :
+            std::runtime_error(what) {
+        }
+
+    }; // struct not_found
+
+    /**
+     * @brief Indexing of OSM data, Locations, etc.
+     */
+    namespace index {
+
+        template <typename TKey>
+        OSMIUM_NORETURN void not_found_error(TKey key) {
+            std::stringstream s;
+            s << "id " << key << " not found";
+            throw not_found(s.str());
+        }
+
+        /**
+         * Some of the index classes need an "empty" value that can
+         * never appear in real data. This function must return this
+         * empty value for any class used as a value in an index.
+         * The default implementation returns a default constructed
+         * object, but it can be specialized.
+         */
+        template <typename T>
+        inline constexpr T empty_value() {
+            return T{};
+        }
+
+        /**
+         * The size_t value in indexes is usually used for offsets
+         * into a buffer or file. It is unlikely that we ever need
+         * the full range, so the max value is a good "empty" value.
+         */
+        template <>
+        inline constexpr size_t empty_value<size_t>() {
+            return std::numeric_limits<size_t>::max();
+        }
+
+    } // namespace index
+
+} // namespace osmium
+
+#endif // OSMIUM_INDEX_INDEX_HPP

third_party/libosmium/include/osmium/index/map.hpp

@@ -0,0 +1,275 @@
+#ifndef OSMIUM_INDEX_MAP_HPP
+#define OSMIUM_INDEX_MAP_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <algorithm>
+#include <cstddef>
+#include <functional>
+#include <map>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#include <osmium/util/compatibility.hpp>
+#include <osmium/util/string.hpp>
+
+namespace osmium {
+
+    namespace index {
+
+        /**
+         * @brief Key-value containers with unique integer values for a key
+         */
+        namespace map {
+
+            /**
+             * This abstract class defines an interface to storage classes
+             * intended for storing small pieces of data (such as coordinates)
+             * indexed by a positive integer (such as an object ID). The
+             * storage must be very space efficient and able to scale to billions
+             * of objects.
+             *
+             * Subclasses have different implementations that store the
+             * data in different ways in memory and/or on disk. Some storage
+             * classes are better suited when working with the whole planet,
+             * some are better for data extracts.
+             *
+             * Note that these classes are not required to track "empty" fields.
+             * When reading data you have to be sure you have put something in
+             * there before.
+             *
+             * A typical use for this and derived classes is storage of node
+             * locations indexed by node ID. These indexes will only work
+             * on 64 bit systems if used in this case. 32 bit systems just
+             * can't address that much memory!
+             *
+             * @tparam TId Id type, usually osmium::unsigned_object_id_type,
+             *             must be an unsigned integral type.
+             * @tparam TValue Value type, usually osmium::Location or size_t.
+             *                Copied by value, so should be "small" type.
+             */
+            template <typename TId, typename TValue>
+            class Map {
+
+                static_assert(std::is_integral<TId>::value && std::is_unsigned<TId>::value,
+                              "TId template parameter for class Map must be unsigned integral type");
+
+                Map(const Map&) = delete;
+                Map& operator=(const Map&) = delete;
+
+            protected:
+
+                Map(Map&&) = default;
+                Map& operator=(Map&&) = default;
+
+            public:
+
+                /// The "key" type, usually osmium::unsigned_object_id_type.
+                typedef TId key_type;
+
+                /// The "value" type, usually a Location or size_t.
+                typedef TValue value_type;
+
+                Map() = default;
+
+                virtual ~Map() noexcept = default;
+
+                virtual void reserve(const size_t) {
+                    // default implementation is empty
+                }
+
+                /// Set the field with id to value.
+                virtual void set(const TId id, const TValue value) = 0;
+
+                /// Retrieve value by id. Does not check for overflow or empty fields.
+                virtual const TValue get(const TId id) const = 0;
+
+                /**
+                 * Get the approximate number of items in the storage. The storage
+                 * might allocate memory in blocks, so this size might not be
+                 * accurate. You can not use this to find out how much memory the
+                 * storage uses. Use used_memory() for that.
+                 */
+                virtual size_t size() const = 0;
+
+                /**
+                 * Get the memory used for this storage in bytes. Note that this
+                 * is not necessarily entirely accurate but an approximation.
+                 * For storage classes that store the data in memory, this is
+                 * the main memory used, for storage classes storing data on disk
+                 * this is the memory used on disk.
+                 */
+                virtual size_t used_memory() const = 0;
+
+                /**
+                 * Clear memory used for this storage. After this you can not
+                 * use the storage container any more.
+                 */
+                virtual void clear() = 0;
+
+                /**
+                 * Sort data in map. Call this after writing all data and
+                 * before reading. Not all implementations need this.
+                 */
+                virtual void sort() {
+                    // default implementation is empty
+                }
+
+                // This function could usually be const in derived classes,
+                // but not always. It could, for instance, sort internal data.
+                // This is why it is not declared const here.
+                virtual void dump_as_list(const int /*fd*/) {
+                    throw std::runtime_error("can't dump as list");
+                }
+
+                // This function could usually be const in derived classes,
+                // but not always. It could, for instance, sort internal data.
+                // This is why it is not declared const here.
+                virtual void dump_as_array(const int /*fd*/) {
+                    throw std::runtime_error("can't dump as array");
+                }
+
+            }; // class Map
+
+        } // namespace map
+
+        template <typename TId, typename TValue>
+        class MapFactory {
+
+        public:
+
+            typedef TId id_type;
+            typedef TValue value_type;
+            typedef osmium::index::map::Map<id_type, value_type> map_type;
+            typedef std::function<map_type*(const std::vector<std::string>&)> create_map_func;
+
+        private:
+
+            std::map<const std::string, create_map_func> m_callbacks;
+
+            MapFactory() = default;
+
+            MapFactory(const MapFactory&) = delete;
+            MapFactory& operator=(const MapFactory&) = delete;
+
+            MapFactory(MapFactory&&) = delete;
+            MapFactory& operator=(MapFactory&&) = delete;
+
+            OSMIUM_NORETURN static void error(const std::string& map_type_name) {
+                std::string error_message {"Support for map type '"};
+                error_message += map_type_name;
+                error_message += "' not compiled into this binary.";
+                throw std::runtime_error(error_message);
+            }
+
+        public:
+
+            static MapFactory<id_type, value_type>& instance() {
+                static MapFactory<id_type, value_type> factory;
+                return factory;
+            }
+
+            bool register_map(const std::string& map_type_name, create_map_func func) {
+                return m_callbacks.emplace(map_type_name, func).second;
+            }
+
+            bool has_map_type(const std::string& map_type_name) const {
+                return m_callbacks.count(map_type_name);
+            }
+
+            std::vector<std::string> map_types() const {
+                std::vector<std::string> result;
+
+                for (const auto& cb : m_callbacks) {
+                    result.push_back(cb.first);
+                }
+
+                std::sort(result.begin(), result.end());
+
+                return result;
+            }
+
+            std::unique_ptr<map_type> create_map(const std::string& config_string) const {
+                std::vector<std::string> config = osmium::split_string(config_string, ',');
+
+                if (config.empty()) {
+                    throw std::runtime_error("Need non-empty map type name.");
+                }
+
+                auto it = m_callbacks.find(config[0]);
+                if (it != m_callbacks.end()) {
+                    return std::unique_ptr<map_type>((it->second)(config));
+                }
+
+                error(config[0]);
+            }
+
+        }; // class MapFactory
+
+        namespace map {
+
+            template <typename TId, typename TValue, template<typename, typename> class TMap>
+            struct create_map {
+                TMap<TId, TValue>* operator()(const std::vector<std::string>&) {
+                    return new TMap<TId, TValue>();
+                }
+            };
+
+        } // namespace map
+
+        template <typename TId, typename TValue, template<typename, typename> class TMap>
+        inline bool register_map(const std::string& name) {
+            return osmium::index::MapFactory<TId, TValue>::instance().register_map(name, [](const std::vector<std::string>& config) {
+                return map::create_map<TId, TValue, TMap>()(config);
+            });
+        }
+
+#define OSMIUM_CONCATENATE_DETAIL_(x, y) x##y
+#define OSMIUM_CONCATENATE_(x, y) OSMIUM_CONCATENATE_DETAIL_(x, y)
+
+#define REGISTER_MAP(id, value, klass, name) \
+namespace osmium { namespace index { namespace detail { \
+    const bool OSMIUM_CONCATENATE_(registered_, name) = osmium::index::register_map<id, value, klass>(#name); \
+    inline bool OSMIUM_CONCATENATE_(get_registered_, name)() noexcept { \
+        return OSMIUM_CONCATENATE_(registered_, name); \
+    } \
+} } }
+
+    } // namespace index
+
+} // namespace osmium
+
+#endif // OSMIUM_INDEX_MAP_HPP

third_party/libosmium/include/osmium/index/map/all.hpp

@@ -0,0 +1,46 @@
+#ifndef OSMIUM_INDEX_MAP_ALL_HPP
+#define OSMIUM_INDEX_MAP_ALL_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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/index/map/dense_file_array.hpp>  // IWYU pragma: keep
+#include <osmium/index/map/dense_mem_array.hpp>   // IWYU pragma: keep
+#include <osmium/index/map/dense_mmap_array.hpp>  // IWYU pragma: keep
+#include <osmium/index/map/dummy.hpp>             // IWYU pragma: keep
+#include <osmium/index/map/sparse_file_array.hpp> // IWYU pragma: keep
+#include <osmium/index/map/sparse_mem_array.hpp>  // IWYU pragma: keep
+#include <osmium/index/map/sparse_mem_map.hpp>    // IWYU pragma: keep
+#include <osmium/index/map/sparse_mem_table.hpp>  // IWYU pragma: keep
+#include <osmium/index/map/sparse_mmap_array.hpp> // IWYU pragma: keep
+
+#endif // OSMIUM_INDEX_MAP_ALL_HPP

third_party/libosmium/include/osmium/index/map/dense_file_array.hpp

@@ -0,0 +1,67 @@
+#ifndef OSMIUM_INDEX_MAP_DENSE_FILE_ARRAY_HPP
+#define OSMIUM_INDEX_MAP_DENSE_FILE_ARRAY_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <string>
+#include <vector>
+
+#include <osmium/index/detail/mmap_vector_file.hpp>
+#include <osmium/index/detail/vector_map.hpp>
+#include <osmium/index/detail/create_map_with_fd.hpp>
+
+#define OSMIUM_HAS_INDEX_MAP_DENSE_FILE_ARRAY
+
+namespace osmium {
+
+    namespace index {
+
+        namespace map {
+
+            template <typename TId, typename TValue>
+            using DenseFileArray = VectorBasedDenseMap<osmium::detail::mmap_vector_file<TValue>, TId, TValue>;
+
+            template <typename TId, typename TValue>
+            struct create_map<TId, TValue, DenseFileArray> {
+                DenseFileArray<TId, TValue>* operator()(const std::vector<std::string>& config) {
+                    return osmium::index::detail::create_map_with_fd<DenseFileArray<TId, TValue>>(config);
+                }
+            };
+
+        } // namespace map
+
+    } // namespace index
+
+} // namespace osmium
+
+#endif // OSMIUM_INDEX_MAP_DENSE_FILE_ARRAY_HPP

third_party/libosmium/include/osmium/index/map/dense_mem_array.hpp

@@ -0,0 +1,57 @@
+#ifndef OSMIUM_INDEX_MAP_DENSE_MEM_ARRAY_HPP
+#define OSMIUM_INDEX_MAP_DENSE_MEM_ARRAY_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <vector>
+
+#include <osmium/index/detail/vector_map.hpp>
+
+#define OSMIUM_HAS_INDEX_MAP_DENSE_MEM_ARRAY
+
+namespace osmium {
+
+    namespace index {
+
+        namespace map {
+
+            template <typename TId, typename TValue>
+            using DenseMemArray = VectorBasedDenseMap<std::vector<TValue>, TId, TValue>;
+
+        } // namespace map
+
+    } // namespace index
+
+} // namespace osmium
+
+#endif // OSMIUM_INDEX_MAP_DENSE_MEM_ARRAY_HPP

third_party/libosmium/include/osmium/index/map/dense_mmap_array.hpp

@@ -0,0 +1,60 @@
+#ifndef OSMIUM_INDEX_MAP_DENSE_MMAP_ARRAY_HPP
+#define OSMIUM_INDEX_MAP_DENSE_MMAP_ARRAY_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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.
+
+*/
+
+#ifdef __linux__
+
+#include <osmium/index/detail/mmap_vector_anon.hpp> // IWYU pragma: keep
+#include <osmium/index/detail/vector_map.hpp>
+
+#define OSMIUM_HAS_INDEX_MAP_DENSE_MMAP_ARRAY
+
+namespace osmium {
+
+    namespace index {
+
+        namespace map {
+
+            template <typename TId, typename TValue>
+            using DenseMmapArray = VectorBasedDenseMap<osmium::detail::mmap_vector_anon<TValue>, TId, TValue>;
+
+        } // namespace map
+
+    } // namespace index
+
+} // namespace osmium
+
+#endif // __linux__
+
+#endif // OSMIUM_INDEX_MAP_DENSE_MMAP_ARRAY_HPP

third_party/libosmium/include/osmium/index/map/dummy.hpp

@@ -0,0 +1,88 @@
+#ifndef OSMIUM_INDEX_MAP_DUMMY_HPP
+#define OSMIUM_INDEX_MAP_DUMMY_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <cstddef>
+
+#include <osmium/index/index.hpp>
+#include <osmium/index/map.hpp>
+
+namespace osmium {
+
+    namespace index {
+
+        namespace map {
+
+            /**
+             * Pseudo map.
+             * Use this class if you don't need a map, but you
+             * need an object that behaves like one.
+             */
+            template <typename TId, typename TValue>
+            class Dummy : public osmium::index::map::Map<TId, TValue> {
+
+            public:
+
+                Dummy() = default;
+
+                ~Dummy() noexcept final = default;
+
+                void set(const TId, const TValue) final {
+                    // intentionally left blank
+                }
+
+                const TValue get(const TId id) const final {
+                    not_found_error(id);
+                }
+
+                size_t size() const final {
+                    return 0;
+                }
+
+                size_t used_memory() const final {
+                    return 0;
+                }
+
+                void clear() final {
+                }
+
+            }; // class Dummy
+
+        } // namespace map
+
+    } // namespace index
+
+} // namespace osmium
+
+#endif // OSMIUM_INDEX_MAP_DUMMY_HPP

third_party/libosmium/include/osmium/index/map/sparse_file_array.hpp

@@ -0,0 +1,67 @@
+#ifndef OSMIUM_INDEX_MAP_SPARSE_FILE_ARRAY_HPP
+#define OSMIUM_INDEX_MAP_SPARSE_FILE_ARRAY_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <string>
+#include <vector>
+
+#include <osmium/index/detail/mmap_vector_file.hpp>
+#include <osmium/index/detail/vector_map.hpp>
+#include <osmium/index/detail/create_map_with_fd.hpp>
+
+#define OSMIUM_HAS_INDEX_MAP_SPARSE_FILE_ARRAY
+
+namespace osmium {
+
+    namespace index {
+
+        namespace map {
+
+            template <typename TId, typename TValue>
+            using SparseFileArray = VectorBasedSparseMap<TId, TValue, osmium::detail::mmap_vector_file>;
+
+            template <typename TId, typename TValue>
+            struct create_map<TId, TValue, SparseFileArray> {
+                SparseFileArray<TId, TValue>* operator()(const std::vector<std::string>& config) {
+                    return osmium::index::detail::create_map_with_fd<SparseFileArray<TId, TValue>>(config);
+                }
+            };
+
+        } // namespace map
+
+    } // namespace index
+
+} // namespace osmium
+
+#endif // OSMIUM_INDEX_MAP_SPARSE_FILE_ARRAY_HPP

third_party/libosmium/include/osmium/index/map/sparse_mem_array.hpp

@@ -0,0 +1,60 @@
+#ifndef OSMIUM_INDEX_MAP_SPARSE_MEM_ARRAY_HPP
+#define OSMIUM_INDEX_MAP_SPARSE_MEM_ARRAY_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <vector>
+
+#include <osmium/index/detail/vector_map.hpp>
+
+#define OSMIUM_HAS_INDEX_MAP_SPARSE_MEM_ARRAY
+
+namespace osmium {
+
+    namespace index {
+
+        namespace map {
+
+            template <typename T>
+            using StdVectorWrap = std::vector<T>;
+
+            template <typename TId, typename TValue>
+            using SparseMemArray = VectorBasedSparseMap<TId, TValue, StdVectorWrap>;
+
+        } // namespace map
+
+    } // namespace index
+
+} // namespace osmium
+
+#endif // OSMIUM_INDEX_MAP_SPARSE_MEM_ARRAY_HPP

third_party/libosmium/include/osmium/index/map/sparse_mem_map.hpp

@@ -0,0 +1,116 @@
+#ifndef OSMIUM_INDEX_MAP_SPARSE_MEM_MAP_HPP
+#define OSMIUM_INDEX_MAP_SPARSE_MEM_MAP_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <algorithm> // IWYU pragma: keep (for std::copy)
+#include <cstddef>
+#include <iterator>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+#include <osmium/index/map.hpp>
+#include <osmium/index/index.hpp>
+#include <osmium/io/detail/read_write.hpp>
+
+#define OSMIUM_HAS_INDEX_MAP_SPARSE_MEM_MAP
+
+namespace osmium {
+
+    namespace index {
+
+        namespace map {
+
+            /**
+             * This implementation uses std::map internally. It uses rather a
+             * lot of memory, but might make sense for small maps.
+             */
+            template <typename TId, typename TValue>
+            class SparseMemMap : public osmium::index::map::Map<TId, TValue> {
+
+                // This is a rough estimate for the memory needed for each
+                // element in the map (id + value + pointers to left, right,
+                // and parent plus some overhead for color of red-black-tree
+                // or similar).
+                static constexpr size_t element_size = sizeof(TId) + sizeof(TValue) + sizeof(void*) * 4;
+
+                std::map<TId, TValue> m_elements;
+
+            public:
+
+                SparseMemMap() = default;
+
+                ~SparseMemMap() noexcept final = default;
+
+                void set(const TId id, const TValue value) final {
+                    m_elements[id] = value;
+                }
+
+                const TValue get(const TId id) const final {
+                    auto it = m_elements.find(id);
+                    if (it == m_elements.end()) {
+                        not_found_error(id);
+                    }
+                    return it->second;
+                }
+
+                size_t size() const noexcept final {
+                    return m_elements.size();
+                }
+
+                size_t used_memory() const noexcept final {
+                    return element_size * m_elements.size();
+                }
+
+                void clear() final {
+                    m_elements.clear();
+                }
+
+                void dump_as_list(const int fd) final {
+                    typedef typename std::map<TId, TValue>::value_type t;
+                    std::vector<t> v;
+                    v.reserve(m_elements.size());
+                    std::copy(m_elements.cbegin(), m_elements.cend(), std::back_inserter(v));
+                    osmium::io::detail::reliable_write(fd, reinterpret_cast<const char*>(v.data()), sizeof(t) * v.size());
+                }
+
+            }; // class SparseMemMap
+
+        } // namespace map
+
+    } // namespace index
+
+} // namespace osmium
+
+#endif // OSMIUM_INDEX_MAP_SPARSE_MEM_MAP_HPP

third_party/libosmium/include/osmium/index/map/sparse_mem_table.hpp

@@ -0,0 +1,147 @@
+#ifndef OSMIUM_INDEX_MAP_SPARSE_MEM_TABLE_HPP
+#define OSMIUM_INDEX_MAP_SPARSE_MEM_TABLE_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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.
+
+*/
+
+#ifdef OSMIUM_WITH_SPARSEHASH
+
+#include <cstddef>
+#include <utility>
+#include <vector>
+
+#include <google/sparsetable>
+
+#include <osmium/index/index.hpp>
+#include <osmium/index/map.hpp>
+#include <osmium/io/detail/read_write.hpp>
+
+#define OSMIUM_HAS_INDEX_MAP_SPARSE_MEM_TABLE
+
+namespace osmium {
+
+    namespace index {
+
+        namespace map {
+
+            /**
+            * The SparseMemTable index stores elements in a Google sparsetable,
+            * a data structure that can hold sparsly filled tables in a
+            * space efficient way. It will resize automatically.
+            *
+            * Use this index if the ID space is only sparsly
+            * populated, such as when working with smaller OSM files (like
+            * country extracts).
+            *
+            * This will only work on 64 bit machines.
+            */
+            template <typename TId, typename TValue>
+            class SparseMemTable : public osmium::index::map::Map<TId, TValue> {
+
+                TId m_grow_size;
+
+                google::sparsetable<TValue> m_elements;
+
+                static_assert(sizeof(typename google::sparsetable<TValue>::size_type) >= 8, "google::sparsetable needs 64bit machine");
+
+            public:
+
+                /**
+                * Constructor.
+                *
+                * @param grow_size The initial size of the index (ie number of
+                *                  elements that fit into the index).
+                *                  The storage will grow by at least this size
+                *                  every time it runs out of space.
+                */
+                explicit SparseMemTable(const TId grow_size = 10000) :
+                    m_grow_size(grow_size),
+                    m_elements(grow_size) {
+                }
+
+                ~SparseMemTable() noexcept final = default;
+
+                void set(const TId id, const TValue value) final {
+                    if (id >= m_elements.size()) {
+                        m_elements.resize(id + m_grow_size);
+                    }
+                    m_elements[id] = value;
+                }
+
+                const TValue get(const TId id) const final {
+                    if (id >= m_elements.size()) {
+                        not_found_error(id);
+                    }
+                    if (m_elements[id] == osmium::index::empty_value<TValue>()) {
+                        not_found_error(id);
+                    }
+                    return m_elements[id];
+                }
+
+                size_t size() const final {
+                    return m_elements.size();
+                }
+
+                size_t used_memory() const final {
+                    // unused elements use 1 bit, used elements sizeof(TValue) bytes
+                    // http://google-sparsehash.googlecode.com/svn/trunk/doc/sparsetable.html
+                    return (m_elements.size() / 8) + (m_elements.num_nonempty() * sizeof(TValue));
+                }
+
+                void clear() final {
+                    m_elements.clear();
+                }
+
+                void dump_as_list(const int fd) final {
+                    std::vector<std::pair<TId, TValue>> v;
+                    v.reserve(m_elements.size());
+                    int n = 0;
+                    for (const TValue value : m_elements) {
+                        if (value != osmium::index::empty_value<TValue>()) {
+                            v.emplace_back(n, value);
+                        }
+                        ++n;
+                    }
+                    osmium::io::detail::reliable_write(fd, reinterpret_cast<const char*>(v.data()), sizeof(std::pair<TId, TValue>) * v.size());
+                }
+
+            }; // class SparseMemTable
+
+        } // namespace map
+
+    } // namespace index
+
+} // namespace osmium
+
+#endif // OSMIUM_WITH_SPARSEHASH
+
+#endif // OSMIUM_INDEX_BYID_SPARSE_MEM_TABLE_HPP

third_party/libosmium/include/osmium/index/map/sparse_mmap_array.hpp

@@ -0,0 +1,60 @@
+#ifndef OSMIUM_INDEX_MAP_SPARSE_MMAP_ARRAY_HPP
+#define OSMIUM_INDEX_MAP_SPARSE_MMAP_ARRAY_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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.
+
+*/
+
+#ifdef __linux__
+
+#include <osmium/index/detail/mmap_vector_anon.hpp>
+#include <osmium/index/detail/vector_map.hpp>
+
+#define OSMIUM_HAS_INDEX_MAP_SPARSE_MMAP_ARRAY
+
+namespace osmium {
+
+    namespace index {
+
+        namespace map {
+
+            template <typename TId, typename TValue>
+            using SparseMmapArray = VectorBasedSparseMap<TId, TValue, osmium::detail::mmap_vector_anon>;
+
+        } // namespace map
+
+    } // namespace index
+
+} // namespace osmium
+
+#endif // __linux__
+
+#endif // OSMIUM_INDEX_MAP_SPARSE_MMAP_ARRAY_HPP

third_party/libosmium/include/osmium/index/multimap.hpp

@@ -0,0 +1,127 @@
+#ifndef OSMIUM_INDEX_MULTIMAP_HPP
+#define OSMIUM_INDEX_MULTIMAP_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <cstddef>
+#include <stdexcept>
+#include <type_traits>
+#include <utility>
+
+namespace osmium {
+
+    namespace index {
+
+        /**
+         * @brief Key-value containers with multiple values for an integer key
+         */
+        namespace multimap {
+
+            template <typename TId, typename TValue>
+            class Multimap {
+
+                static_assert(std::is_integral<TId>::value && std::is_unsigned<TId>::value, "TId template parameter for class Multimap must be unsigned integral type");
+
+                typedef typename std::pair<TId, TValue> element_type;
+
+                Multimap(const Multimap&) = delete;
+                Multimap& operator=(const Multimap&) = delete;
+
+            protected:
+
+                Multimap(Multimap&&) = default;
+                Multimap& operator=(Multimap&&) = default;
+
+            public:
+
+                /// The "key" type, usually osmium::unsigned_object_id_type.
+                typedef TId key_type;
+
+                /// The "value" type, usually a Location or size_t.
+                typedef TValue value_type;
+
+                Multimap() = default;
+
+                virtual ~Multimap() noexcept = default;
+
+                /// Set the field with id to value.
+                virtual void set(const TId id, const TValue value) = 0;
+
+                typedef element_type* iterator;
+
+//                virtual std::pair<iterator, iterator> get_all(const TId id) const = 0;
+
+                /**
+                 * Get the approximate number of items in the storage. The storage
+                 * might allocate memory in blocks, so this size might not be
+                 * accurate. You can not use this to find out how much memory the
+                 * storage uses. Use used_memory() for that.
+                 */
+                virtual size_t size() const = 0;
+
+                /**
+                 * Get the memory used for this storage in bytes. Note that this
+                 * is not necessarily entirely accurate but an approximation.
+                 * For storage classes that store the data in memory, this is
+                 * the main memory used, for storage classes storing data on disk
+                 * this is the memory used on disk.
+                 */
+                virtual size_t used_memory() const = 0;
+
+                /**
+                 * Clear memory used for this storage. After this you can not
+                 * use the storage container any more.
+                 */
+                virtual void clear() = 0;
+
+                /**
+                 * Sort data in map. Call this after writing all data and
+                 * before reading. Not all implementations need this.
+                 */
+                virtual void sort() {
+                    // default implementation is empty
+                }
+
+                virtual void dump_as_list(const int /*fd*/) {
+                    std::runtime_error("can't dump as list");
+                }
+
+            }; // class Multimap
+
+        } // namespace multimap
+
+    } // namespace index
+
+} // namespace osmium
+
+#endif // OSMIUM_INDEX_MULTIMAP_HPP

third_party/libosmium/include/osmium/index/multimap/all.hpp

@@ -0,0 +1,41 @@
+#ifndef OSMIUM_INDEX_MULTIMAP_ALL_HPP
+#define OSMIUM_INDEX_MULTIMAP_ALL_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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/index/multimap/sparse_file_array.hpp>   // IWYU pragma: keep
+#include <osmium/index/multimap/sparse_mem_array.hpp>    // IWYU pragma: keep
+#include <osmium/index/multimap/sparse_mem_multimap.hpp> // IWYU pragma: keep
+#include <osmium/index/multimap/sparse_mmap_array.hpp>   // IWYU pragma: keep
+
+#endif // OSMIUM_INDEX_MULTIMAP_ALL_HPP

third_party/libosmium/include/osmium/index/multimap/hybrid.hpp

@@ -0,0 +1,204 @@
+#ifndef OSMIUM_INDEX_MULTIMAP_HYBRID_HPP
+#define OSMIUM_INDEX_MULTIMAP_HYBRID_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <cstddef>
+#include <utility>
+
+#include <osmium/index/index.hpp>
+#include <osmium/index/multimap.hpp>
+#include <osmium/index/multimap/sparse_mem_array.hpp>
+#include <osmium/index/multimap/sparse_mem_multimap.hpp>
+
+namespace osmium {
+
+    namespace index {
+
+        namespace multimap {
+
+            template <typename TId, typename TValue>
+            class HybridIterator {
+
+                typedef SparseMemArray<TId, TValue> main_map_type;
+                typedef SparseMemMultimap<TId, TValue> extra_map_type;
+
+                typedef typename std::pair<TId, TValue> element_type;
+
+                typename main_map_type::iterator m_begin_main;
+                typename main_map_type::iterator m_end_main;
+                typename extra_map_type::iterator m_begin_extra;
+                typename extra_map_type::iterator m_end_extra;
+
+            public:
+
+                 HybridIterator(typename main_map_type::iterator begin_main,
+                                typename main_map_type::iterator end_main,
+                                typename extra_map_type::iterator begin_extra,
+                                typename extra_map_type::iterator end_extra) :
+                    m_begin_main(begin_main),
+                    m_end_main(end_main),
+                    m_begin_extra(begin_extra),
+                    m_end_extra(end_extra) {
+                }
+
+                ~HybridIterator() noexcept = default;
+
+                HybridIterator& operator++() {
+                    if (m_begin_main == m_end_main) {
+                        ++m_begin_extra;
+                    } else {
+                        ++m_begin_main;
+                        while (m_begin_main != m_end_main && m_begin_main->second == osmium::index::empty_value<TValue>()) { // ignore removed elements
+                            ++m_begin_main;
+                        }
+                    }
+                    return *this;
+                }
+
+                HybridIterator<TId, TValue> operator++(int) {
+                    auto tmp(*this);
+                    operator++();
+                    return tmp;
+                }
+
+                bool operator==(const HybridIterator& rhs) const {
+                    return m_begin_main == rhs.m_begin_main &&
+                           m_end_main   == rhs.m_end_main &&
+                           m_begin_extra == rhs.m_begin_extra &&
+                           m_end_extra   == rhs.m_end_extra;
+                }
+
+                bool operator!=(const HybridIterator& rhs) const {
+                    return ! operator==(rhs);
+                }
+
+                const element_type& operator*() {
+                    if (m_begin_main == m_end_main) {
+                        return *m_begin_extra;
+                    } else {
+                        return *m_begin_main;
+                    }
+                }
+
+                const element_type* operator->() {
+                    return &operator*();
+                }
+
+            }; // class HybridIterator
+
+            template <typename TId, typename TValue>
+            class Hybrid : public Multimap<TId, TValue> {
+
+                typedef SparseMemArray<TId, TValue> main_map_type;
+                typedef SparseMemMultimap<TId, TValue> extra_map_type;
+
+                main_map_type m_main;
+                extra_map_type m_extra;
+
+            public:
+
+                typedef HybridIterator<TId, TValue> iterator;
+                typedef const HybridIterator<TId, TValue> const_iterator;
+
+                Hybrid() :
+                    m_main(),
+                    m_extra() {
+                }
+
+                ~Hybrid() noexcept = default;
+
+                size_t size() const final {
+                    return m_main.size() + m_extra.size();
+                }
+
+                size_t used_memory() const final {
+                    return m_main.used_memory() + m_extra.used_memory();
+                }
+
+                void reserve(const size_t size) {
+                    m_main.reserve(size);
+                }
+
+                void unsorted_set(const TId id, const TValue value) {
+                    m_main.set(id, value);
+                }
+
+                void set(const TId id, const TValue value) final {
+                    m_extra.set(id, value);
+                }
+
+                std::pair<iterator, iterator> get_all(const TId id) {
+                    auto result_main = m_main.get_all(id);
+                    auto result_extra = m_extra.get_all(id);
+                    return std::make_pair(iterator(result_main.first, result_main.second, result_extra.first, result_extra.second),
+                                          iterator(result_main.second, result_main.second, result_extra.second, result_extra.second));
+                }
+
+                void remove(const TId id, const TValue value) {
+                    m_main.remove(id, value);
+                    m_extra.remove(id, value);
+                }
+
+                void consolidate() {
+                    m_main.erase_removed();
+                    for (const auto& element : m_extra) {
+                        m_main.set(element.first, element.second);
+                    }
+                    m_extra.clear();
+                    m_main.sort();
+                }
+
+                void dump_as_list(const int fd) final {
+                    consolidate();
+                    m_main.dump_as_list(fd);
+                }
+
+                void clear() final {
+                    m_main.clear();
+                    m_extra.clear();
+                }
+
+                void sort() final {
+                    m_main.sort();
+                }
+
+            }; // class Hybrid
+
+        } // namespace multimap
+
+    } // namespace index
+
+} // namespace osmium
+
+#endif // OSMIUM_INDEX_MULTIMAP_HYBRID_HPP

third_party/libosmium/include/osmium/index/multimap/sparse_file_array.hpp

@@ -0,0 +1,54 @@
+#ifndef OSMIUM_INDEX_MULTIMAP_SPARSE_FILE_ARRAY_HPP
+#define OSMIUM_INDEX_MULTIMAP_SPARSE_FILE_ARRAY_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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/index/detail/mmap_vector_file.hpp>
+#include <osmium/index/detail/vector_multimap.hpp>
+
+namespace osmium {
+
+    namespace index {
+
+        namespace multimap {
+
+            template <typename TId, typename TValue>
+            using SparseFileArray = VectorBasedSparseMultimap<TId, TValue, osmium::detail::mmap_vector_file>;
+
+        } // namespace multimap
+
+    } // namespace index
+
+} // namespace osmium
+
+#endif // OSMIUM_INDEX_MULTIMAP_SPARSE_FILE_ARRAY_HPP

third_party/libosmium/include/osmium/index/multimap/sparse_mem_array.hpp

@@ -0,0 +1,58 @@
+#ifndef OSMIUM_INDEX_MULTIMAP_SPARSE_MEM_ARRAY_HPP
+#define OSMIUM_INDEX_MULTIMAP_SPARSE_MEM_ARRAY_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <vector>
+
+#include <osmium/index/detail/vector_multimap.hpp>
+
+namespace osmium {
+
+    namespace index {
+
+        namespace multimap {
+
+            template <typename T>
+            using StdVectorWrap = std::vector<T>;
+
+            template <typename TId, typename TValue>
+            using SparseMemArray = VectorBasedSparseMultimap<TId, TValue, StdVectorWrap>;
+
+        } // namespace multimap
+
+    } // namespace index
+
+} // namespace osmium
+
+#endif // OSMIUM_INDEX_MULTIMAP_SPARSE_MEM_ARRAY_HPP

third_party/libosmium/include/osmium/index/multimap/sparse_mem_multimap.hpp

@@ -0,0 +1,151 @@
+#ifndef OSMIUM_INDEX_MULTIMAP_SPARSE_MEM_MULTIMAP_HPP
+#define OSMIUM_INDEX_MULTIMAP_SPARSE_MEM_MULTIMAP_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <algorithm>
+#include <cstddef>
+#include <map>
+#include <utility>
+#include <vector>
+
+#include <osmium/index/multimap.hpp>
+#include <osmium/io/detail/read_write.hpp>
+
+namespace osmium {
+
+    namespace index {
+
+        namespace multimap {
+
+            /**
+             * This implementation uses std::multimap internally. It uses rather a
+             * lot of memory, but might make sense for small maps.
+             */
+            template <typename TId, typename TValue>
+            class SparseMemMultimap : public osmium::index::multimap::Multimap<TId, TValue> {
+
+                // This is a rough estimate for the memory needed for each
+                // element in the map (id + value + pointers to left, right,
+                // and parent plus some overhead for color of red-black-tree
+                // or similar).
+                static constexpr size_t element_size = sizeof(TId) + sizeof(TValue) + sizeof(void*) * 4;
+
+            public:
+
+                typedef typename std::multimap<const TId, TValue> collection_type;
+                typedef typename collection_type::iterator iterator;
+                typedef typename collection_type::const_iterator const_iterator;
+                typedef typename collection_type::value_type value_type;
+
+                typedef typename std::pair<TId, TValue> element_type;
+
+            private:
+
+                collection_type m_elements;
+
+            public:
+
+                SparseMemMultimap() = default;
+
+                ~SparseMemMultimap() noexcept final = default;
+
+                void unsorted_set(const TId id, const TValue value) {
+                    m_elements.emplace(id, value);
+                }
+
+                void set(const TId id, const TValue value) final {
+                    m_elements.emplace(id, value);
+                }
+
+                std::pair<iterator, iterator> get_all(const TId id) {
+                    return m_elements.equal_range(id);
+                }
+
+                std::pair<const_iterator, const_iterator> get_all(const TId id) const {
+                    return m_elements.equal_range(id);
+                }
+
+                void remove(const TId id, const TValue value) {
+                    std::pair<iterator, iterator> r = get_all(id);
+                    for (iterator it = r.first; it != r.second; ++it) {
+                        if (it->second == value) {
+                            m_elements.erase(it);
+                            return;
+                        }
+                    }
+                }
+
+                iterator begin() {
+                    return m_elements.begin();
+                }
+
+                iterator end() {
+                    return m_elements.end();
+                }
+
+                size_t size() const final {
+                    return m_elements.size();
+                }
+
+                size_t used_memory() const final {
+                    return element_size * m_elements.size();
+                }
+
+                void clear() final {
+                    m_elements.clear();
+                }
+
+                void consolidate() {
+                    // intentionally left blank
+                }
+
+                void dump_as_list(const int fd) final {
+                    std::vector<element_type> v;
+                    v.reserve(m_elements.size());
+                    for (const auto& element : m_elements) {
+                        v.emplace_back(element.first, element.second);
+                    }
+                    std::sort(v.begin(), v.end());
+                    osmium::io::detail::reliable_write(fd, reinterpret_cast<const char*>(v.data()), sizeof(element_type) * v.size());
+                }
+
+            }; // class SparseMemMultimap
+
+        } // namespace multimap
+
+    } // namespace index
+
+} // namespace osmium
+
+#endif // OSMIUM_INDEX_MULTIMAP_SPARSE_MEM_MULTIMAP_HPP

third_party/libosmium/include/osmium/index/multimap/sparse_mmap_array.hpp

@@ -0,0 +1,58 @@
+#ifndef OSMIUM_INDEX_MULTIMAP_SPARSE_MMAP_ARRAY_HPP
+#define OSMIUM_INDEX_MULTIMAP_SPARSE_MMAP_ARRAY_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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.
+
+*/
+
+#ifdef __linux__
+
+#include <osmium/index/detail/mmap_vector_anon.hpp>
+#include <osmium/index/detail/vector_multimap.hpp>
+
+namespace osmium {
+
+    namespace index {
+
+        namespace multimap {
+
+            template <typename TId, typename TValue>
+            using SparseMmapArray = VectorBasedSparseMultimap<TId, TValue, osmium::detail::mmap_vector_anon>;
+
+        } // namespace multimap
+
+    } // namespace index
+
+} // namespace osmium
+
+#endif // __linux__
+
+#endif // OSMIUM_INDEX_MULTIMAP_SPARSE_MMAP_ARRAY_HPP

third_party/libosmium/include/osmium/index/node_locations_map.hpp

@@ -0,0 +1,70 @@
+#ifndef OSMIUM_INDEX_NODE_LOCATIONS_MAP_HPP
+#define OSMIUM_INDEX_NODE_LOCATIONS_MAP_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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/index/map.hpp> // IWYU pragma: keep
+
+#ifdef OSMIUM_HAS_INDEX_MAP_DENSE_FILE_ARRAY
+    REGISTER_MAP(osmium::unsigned_object_id_type, osmium::Location, osmium::index::map::DenseFileArray, dense_file_array)
+#endif
+
+#ifdef OSMIUM_HAS_INDEX_MAP_DENSE_MEM_ARRAY
+    REGISTER_MAP(osmium::unsigned_object_id_type, osmium::Location, osmium::index::map::DenseMemArray, dense_mem_array)
+#endif
+
+#ifdef OSMIUM_HAS_INDEX_MAP_DENSE_MMAP_ARRAY
+    REGISTER_MAP(osmium::unsigned_object_id_type, osmium::Location, osmium::index::map::DenseMmapArray, dense_mmap_array)
+#endif
+
+#ifdef OSMIUM_HAS_INDEX_MAP_SPARSE_FILE_ARRAY
+    REGISTER_MAP(osmium::unsigned_object_id_type, osmium::Location, osmium::index::map::SparseFileArray, sparse_file_array)
+#endif
+
+#ifdef OSMIUM_HAS_INDEX_MAP_SPARSE_MEM_ARRAY
+    REGISTER_MAP(osmium::unsigned_object_id_type, osmium::Location, osmium::index::map::SparseMemArray, sparse_mem_array)
+#endif
+
+#ifdef OSMIUM_HAS_INDEX_MAP_SPARSE_MEM_MAP
+    REGISTER_MAP(osmium::unsigned_object_id_type, osmium::Location, osmium::index::map::SparseMemMap, sparse_mem_map)
+#endif
+
+#ifdef OSMIUM_HAS_INDEX_MAP_SPARSE_MEM_TABLE
+    REGISTER_MAP(osmium::unsigned_object_id_type, osmium::Location, osmium::index::map::SparseMemTable, sparse_mem_table)
+#endif
+
+#ifdef OSMIUM_HAS_INDEX_MAP_SPARSE_MMAP_ARRAY
+    REGISTER_MAP(osmium::unsigned_object_id_type, osmium::Location, osmium::index::map::SparseMmapArray, sparse_mmap_array)
+#endif
+
+#endif // OSMIUM_INDEX_NODE_LOCATIONS_MAP_HPP

third_party/libosmium/include/osmium/io/any_compression.hpp

@@ -0,0 +1,48 @@
+#ifndef OSMIUM_IO_ANY_COMPRESSION_HPP
+#define OSMIUM_IO_ANY_COMPRESSION_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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.
+
+*/
+
+/**
+ * @file
+ *
+ * Include this file if you want to read or write compressed OSM XML files.
+ *
+ * @attention If you include this file, you'll need to link with `libz`
+ *            and `libbz2`.
+ */
+
+#include <osmium/io/bzip2_compression.hpp> // IWYU pragma: export
+#include <osmium/io/gzip_compression.hpp> // IWYU pragma: export
+
+#endif // OSMIUM_IO_ANY_COMPRESSION_HPP

third_party/libosmium/include/osmium/io/any_input.hpp

@@ -0,0 +1,52 @@
+#ifndef OSMIUM_IO_ANY_INPUT_HPP
+#define OSMIUM_IO_ANY_INPUT_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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.
+
+*/
+
+/**
+ * @file
+ *
+ * Include this file if you want to read all kinds of OSM files.
+ *
+ * @attention If you include this file, you'll need to link with
+ *            `ws2_32` (Windows only), `libexpat`, `libz`, `libbz2`,
+ *            and enable multithreading.
+ */
+
+#include <osmium/io/any_compression.hpp> // IWYU pragma: export
+
+#include <osmium/io/pbf_input.hpp> // IWYU pragma: export
+#include <osmium/io/xml_input.hpp> // IWYU pragma: export
+#include <osmium/io/o5m_input.hpp> // IWYU pragma: export
+
+#endif // OSMIUM_IO_ANY_INPUT_HPP

third_party/libosmium/include/osmium/io/any_output.hpp

@@ -0,0 +1,53 @@
+#ifndef OSMIUM_IO_ANY_OUTPUT_HPP
+#define OSMIUM_IO_ANY_OUTPUT_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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.
+
+*/
+
+/**
+ * @file
+ *
+ * Include this file if you want to write all kinds of OSM files.
+ *
+ * @attention If you include this file, you'll need to link with
+ *            `ws2_32` (Windows only), `libz`, `libbz2`, and enable
+ *            multithreading.
+ */
+
+#include <osmium/io/any_compression.hpp> // IWYU pragma: export
+
+#include <osmium/io/debug_output.hpp> // IWYU pragma: export
+#include <osmium/io/opl_output.hpp> // IWYU pragma: export
+#include <osmium/io/pbf_output.hpp> // IWYU pragma: export
+#include <osmium/io/xml_output.hpp> // IWYU pragma: export
+
+#endif // OSMIUM_IO_ANY_OUTPUT_HPP

third_party/libosmium/include/osmium/io/bzip2_compression.hpp

@@ -0,0 +1,321 @@
+#ifndef OSMIUM_IO_BZIP2_COMPRESSION_HPP
+#define OSMIUM_IO_BZIP2_COMPRESSION_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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.
+
+*/
+
+/**
+ * @file
+ *
+ * Include this file if you want to read or write bzip2-compressed OSM XML
+ * files.
+ *
+ * @attention If you include this file, you'll need to link with `libbz2`.
+ */
+
+#include <cerrno>
+#include <cstddef>
+#include <cstdio>
+#include <stdexcept>
+#include <string>
+
+#include <bzlib.h>
+
+#ifndef _MSC_VER
+# include <unistd.h>
+#endif
+
+#include <osmium/io/compression.hpp>
+#include <osmium/io/error.hpp>
+#include <osmium/io/file_compression.hpp>
+#include <osmium/io/writer_options.hpp>
+#include <osmium/util/cast.hpp>
+#include <osmium/util/compatibility.hpp>
+
+namespace osmium {
+
+    /**
+     * Exception thrown when there are problems compressing or
+     * decompressing bzip2 files.
+     */
+    struct bzip2_error : public io_error {
+
+        int bzip2_error_code;
+        int system_errno;
+
+        bzip2_error(const std::string& what, int error_code) :
+            io_error(what),
+            bzip2_error_code(error_code),
+            system_errno(error_code == BZ_IO_ERROR ? errno : 0) {
+        }
+
+    }; // struct bzip2_error
+
+    namespace io {
+
+        namespace detail {
+
+            OSMIUM_NORETURN inline void throw_bzip2_error(BZFILE* bzfile, const char* msg, int bzlib_error = 0) {
+                std::string error("bzip2 error: ");
+                error += msg;
+                error += ": ";
+                int errnum = bzlib_error;
+                if (bzlib_error) {
+                    error += std::to_string(bzlib_error);
+                } else {
+                    error += ::BZ2_bzerror(bzfile, &errnum);
+                }
+                throw osmium::bzip2_error(error, errnum);
+            }
+
+        } // namespace detail
+
+        class Bzip2Compressor : public Compressor {
+
+            FILE* m_file;
+            int m_bzerror;
+            BZFILE* m_bzfile;
+
+        public:
+
+            explicit Bzip2Compressor(int fd, fsync sync) :
+                Compressor(sync),
+                m_file(fdopen(dup(fd), "wb")),
+                m_bzerror(BZ_OK),
+                m_bzfile(::BZ2_bzWriteOpen(&m_bzerror, m_file, 6, 0, 0)) {
+                if (!m_bzfile) {
+                    detail::throw_bzip2_error(m_bzfile, "write open failed", m_bzerror);
+                }
+            }
+
+            ~Bzip2Compressor() noexcept final {
+                try {
+                    close();
+                } catch (...) {
+                    // Ignore any exceptions because destructor must not throw.
+                }
+            }
+
+            void write(const std::string& data) final {
+                int error;
+                ::BZ2_bzWrite(&error, m_bzfile, const_cast<char*>(data.data()), static_cast_with_assert<int>(data.size()));
+                if (error != BZ_OK && error != BZ_STREAM_END) {
+                    detail::throw_bzip2_error(m_bzfile, "write failed", error);
+                }
+            }
+
+            void close() final {
+                if (m_bzfile) {
+                    int error;
+                    ::BZ2_bzWriteClose(&error, m_bzfile, 0, nullptr, nullptr);
+                    m_bzfile = nullptr;
+                    if (m_file) {
+                        if (do_fsync()) {
+                            osmium::io::detail::reliable_fsync(::fileno(m_file));
+                        }
+                        if (fclose(m_file) != 0) {
+                            throw std::system_error(errno, std::system_category(), "Close failed");
+                        }
+                    }
+                    if (error != BZ_OK) {
+                        detail::throw_bzip2_error(m_bzfile, "write close failed", error);
+                    }
+                }
+            }
+
+        }; // class Bzip2Compressor
+
+        class Bzip2Decompressor : public Decompressor {
+
+            FILE* m_file;
+            int m_bzerror;
+            BZFILE* m_bzfile;
+            bool m_stream_end {false};
+
+        public:
+
+            explicit Bzip2Decompressor(int fd) :
+                Decompressor(),
+                m_file(fdopen(dup(fd), "rb")),
+                m_bzerror(BZ_OK),
+                m_bzfile(::BZ2_bzReadOpen(&m_bzerror, m_file, 0, 0, nullptr, 0)) {
+                if (!m_bzfile) {
+                    detail::throw_bzip2_error(m_bzfile, "read open failed", m_bzerror);
+                }
+            }
+
+            ~Bzip2Decompressor() noexcept final {
+                try {
+                    close();
+                } catch (...) {
+                    // Ignore any exceptions because destructor must not throw.
+                }
+            }
+
+            std::string read() final {
+                std::string buffer;
+
+                if (!m_stream_end) {
+                    buffer.resize(osmium::io::Decompressor::input_buffer_size);
+                    int error;
+                    int nread = ::BZ2_bzRead(&error, m_bzfile, const_cast<char*>(buffer.data()), static_cast_with_assert<int>(buffer.size()));
+                    if (error != BZ_OK && error != BZ_STREAM_END) {
+                        detail::throw_bzip2_error(m_bzfile, "read failed", error);
+                    }
+                    if (error == BZ_STREAM_END) {
+                        void* unused;
+                        int nunused;
+                        if (! feof(m_file)) {
+                            ::BZ2_bzReadGetUnused(&error, m_bzfile, &unused, &nunused);
+                            if (error != BZ_OK) {
+                                detail::throw_bzip2_error(m_bzfile, "get unused failed", error);
+                            }
+                            std::string unused_data(static_cast<const char*>(unused), static_cast<std::string::size_type>(nunused));
+                            ::BZ2_bzReadClose(&error, m_bzfile);
+                            if (error != BZ_OK) {
+                                detail::throw_bzip2_error(m_bzfile, "read close failed", error);
+                            }
+                            m_bzfile = ::BZ2_bzReadOpen(&error, m_file, 0, 0, const_cast<void*>(static_cast<const void*>(unused_data.data())), static_cast_with_assert<int>(unused_data.size()));
+                            if (error != BZ_OK) {
+                                detail::throw_bzip2_error(m_bzfile, "read open failed", error);
+                            }
+                        } else {
+                            m_stream_end = true;
+                        }
+                    }
+                    buffer.resize(static_cast<std::string::size_type>(nread));
+                }
+
+                return buffer;
+            }
+
+            void close() final {
+                if (m_bzfile) {
+                    int error;
+                    ::BZ2_bzReadClose(&error, m_bzfile);
+                    m_bzfile = nullptr;
+                    if (m_file) {
+                        if (fclose(m_file) != 0) {
+                            throw std::system_error(errno, std::system_category(), "Close failed");
+                        }
+                    }
+                    if (error != BZ_OK) {
+                        detail::throw_bzip2_error(m_bzfile, "read close failed", error);
+                    }
+                }
+            }
+
+        }; // class Bzip2Decompressor
+
+        class Bzip2BufferDecompressor : public Decompressor {
+
+            const char* m_buffer;
+            size_t m_buffer_size;
+            bz_stream m_bzstream;
+
+        public:
+
+            Bzip2BufferDecompressor(const char* buffer, size_t size) :
+                m_buffer(buffer),
+                m_buffer_size(size),
+                m_bzstream() {
+                m_bzstream.next_in = const_cast<char*>(buffer);
+                m_bzstream.avail_in = static_cast_with_assert<unsigned int>(size);
+                int result = BZ2_bzDecompressInit(&m_bzstream, 0, 0);
+                if (result != BZ_OK) {
+                    std::string message("bzip2 error: decompression init failed: ");
+                    throw bzip2_error(message, result);
+                }
+            }
+
+            ~Bzip2BufferDecompressor() noexcept final {
+                try {
+                    close();
+                } catch (...) {
+                    // Ignore any exceptions because destructor must not throw.
+                }
+            }
+
+            std::string read() final {
+                std::string output;
+
+                if (m_buffer) {
+                    const size_t buffer_size = 10240;
+                    output.resize(buffer_size);
+                    m_bzstream.next_out = const_cast<char*>(output.data());
+                    m_bzstream.avail_out = buffer_size;
+                    int result = BZ2_bzDecompress(&m_bzstream);
+
+                    if (result != BZ_OK) {
+                        m_buffer = nullptr;
+                        m_buffer_size = 0;
+                    }
+
+                    if (result != BZ_OK && result != BZ_STREAM_END) {
+                        std::string message("bzip2 error: decompress failed: ");
+                        throw bzip2_error(message, result);
+                    }
+
+                    output.resize(static_cast<unsigned long>(m_bzstream.next_out - output.data()));
+                }
+
+                return output;
+            }
+
+            void close() final {
+                BZ2_bzDecompressEnd(&m_bzstream);
+            }
+
+        }; // class Bzip2BufferDecompressor
+
+        namespace detail {
+
+            // we want the register_compression() function to run, setting
+            // the variable is only a side-effect, it will never be used
+            const bool registered_bzip2_compression = osmium::io::CompressionFactory::instance().register_compression(osmium::io::file_compression::bzip2,
+                [](int fd, fsync sync) { return new osmium::io::Bzip2Compressor(fd, sync); },
+                [](int fd) { return new osmium::io::Bzip2Decompressor(fd); },
+                [](const char* buffer, size_t size) { return new osmium::io::Bzip2BufferDecompressor(buffer, size); }
+            );
+
+            // dummy function to silence the unused variable warning from above
+            inline bool get_registered_bzip2_compression() noexcept {
+                return registered_bzip2_compression;
+            }
+
+        } // namespace detail
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_BZIP2_COMPRESSION_HPP

third_party/libosmium/include/osmium/io/compression.hpp

@@ -0,0 +1,321 @@
+#ifndef OSMIUM_IO_COMPRESSION_HPP
+#define OSMIUM_IO_COMPRESSION_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <cerrno>
+#include <functional>
+#include <map>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <system_error>
+#include <tuple>
+#include <utility>
+
+#ifndef _MSC_VER
+# include <unistd.h>
+#else
+# include <io.h>
+#endif
+
+#include <osmium/io/detail/read_write.hpp>
+#include <osmium/io/error.hpp>
+#include <osmium/io/file_compression.hpp>
+#include <osmium/io/writer_options.hpp>
+#include <osmium/util/compatibility.hpp>
+
+namespace osmium {
+
+    namespace io {
+
+        class Compressor {
+
+            fsync m_fsync;
+
+        protected:
+
+            bool do_fsync() const {
+                return m_fsync == fsync::yes;
+            }
+
+        public:
+
+            explicit Compressor(fsync sync) :
+                m_fsync(sync) {
+            }
+
+            virtual ~Compressor() noexcept {
+            }
+
+            virtual void write(const std::string& data) = 0;
+
+            virtual void close() = 0;
+
+        }; // class Compressor
+
+        class Decompressor {
+
+        public:
+
+            static constexpr unsigned int input_buffer_size = 1024 * 1024;
+
+            Decompressor() = default;
+
+            Decompressor(const Decompressor&) = delete;
+            Decompressor& operator=(const Decompressor&) = delete;
+
+            Decompressor(Decompressor&&) = delete;
+            Decompressor& operator=(Decompressor&&) = delete;
+
+            virtual ~Decompressor() noexcept {
+            }
+
+            virtual std::string read() = 0;
+
+            virtual void close() = 0;
+
+        }; // class Decompressor
+
+        /**
+         * This singleton factory class is used to register compression
+         * algorithms used for reading and writing OSM files.
+         *
+         * For each algorithm we store two functions that construct
+         * a compressor and decompressor object, respectively.
+         */
+        class CompressionFactory {
+
+        public:
+
+            typedef std::function<osmium::io::Compressor*(int, fsync)> create_compressor_type;
+            typedef std::function<osmium::io::Decompressor*(int)> create_decompressor_type_fd;
+            typedef std::function<osmium::io::Decompressor*(const char*, size_t)> create_decompressor_type_buffer;
+
+        private:
+
+            typedef std::map<const osmium::io::file_compression,
+                             std::tuple<create_compressor_type,
+                                        create_decompressor_type_fd,
+                                        create_decompressor_type_buffer>> compression_map_type;
+
+            compression_map_type m_callbacks;
+
+            CompressionFactory() = default;
+
+            CompressionFactory(const CompressionFactory&) = delete;
+            CompressionFactory& operator=(const CompressionFactory&) = delete;
+
+            CompressionFactory(CompressionFactory&&) = delete;
+            CompressionFactory& operator=(CompressionFactory&&) = delete;
+
+            OSMIUM_NORETURN void error(osmium::io::file_compression compression) {
+                std::string error_message {"Support for compression '"};
+                error_message += as_string(compression);
+                error_message += "' not compiled into this binary.";
+                throw unsupported_file_format_error(error_message);
+            }
+
+        public:
+
+            static CompressionFactory& instance() {
+                static CompressionFactory factory;
+                return factory;
+            }
+
+            bool register_compression(
+                osmium::io::file_compression compression,
+                create_compressor_type create_compressor,
+                create_decompressor_type_fd create_decompressor_fd,
+                create_decompressor_type_buffer create_decompressor_buffer) {
+
+                compression_map_type::value_type cc(compression,
+                                                    std::make_tuple(create_compressor,
+                                                                    create_decompressor_fd,
+                                                                    create_decompressor_buffer));
+
+                return m_callbacks.insert(cc).second;
+            }
+
+            template <typename... TArgs>
+            std::unique_ptr<osmium::io::Compressor> create_compressor(osmium::io::file_compression compression, TArgs&&... args) {
+                auto it = m_callbacks.find(compression);
+
+                if (it != m_callbacks.end()) {
+                    return std::unique_ptr<osmium::io::Compressor>(std::get<0>(it->second)(std::forward<TArgs>(args)...));
+                }
+
+                error(compression);
+            }
+
+            std::unique_ptr<osmium::io::Decompressor> create_decompressor(osmium::io::file_compression compression, int fd) {
+                auto it = m_callbacks.find(compression);
+
+                if (it != m_callbacks.end()) {
+                    return std::unique_ptr<osmium::io::Decompressor>(std::get<1>(it->second)(fd));
+                }
+
+                error(compression);
+            }
+
+            std::unique_ptr<osmium::io::Decompressor> create_decompressor(osmium::io::file_compression compression, const char* buffer, size_t size) {
+                auto it = m_callbacks.find(compression);
+
+                if (it != m_callbacks.end()) {
+                    return std::unique_ptr<osmium::io::Decompressor>(std::get<2>(it->second)(buffer, size));
+                }
+
+                error(compression);
+            }
+
+        }; // class CompressionFactory
+
+        class NoCompressor : public Compressor {
+
+            int m_fd;
+
+        public:
+
+            NoCompressor(int fd, fsync sync) :
+                Compressor(sync),
+                m_fd(fd) {
+            }
+
+            ~NoCompressor() noexcept final {
+                try {
+                    close();
+                } catch (...) {
+                    // Ignore any exceptions because destructor must not throw.
+                }
+            }
+
+            void write(const std::string& data) final {
+                osmium::io::detail::reliable_write(m_fd, data.data(), data.size());
+            }
+
+            void close() final {
+                if (m_fd >= 0) {
+                    int fd = m_fd;
+                    m_fd = -1;
+                    if (do_fsync()) {
+                        osmium::io::detail::reliable_fsync(fd);
+                    }
+                    osmium::io::detail::reliable_close(fd);
+                }
+            }
+
+        }; // class NoCompressor
+
+        class NoDecompressor : public Decompressor {
+
+            int m_fd;
+            const char *m_buffer;
+            size_t m_buffer_size;
+
+        public:
+
+            explicit NoDecompressor(int fd) :
+                Decompressor(),
+                m_fd(fd),
+                m_buffer(nullptr),
+                m_buffer_size(0) {
+            }
+
+            NoDecompressor(const char* buffer, size_t size) :
+                Decompressor(),
+                m_fd(-1),
+                m_buffer(buffer),
+                m_buffer_size(size) {
+            }
+
+            ~NoDecompressor() noexcept final {
+                try {
+                    close();
+                } catch (...) {
+                    // Ignore any exceptions because destructor must not throw.
+                }
+            }
+
+            std::string read() final {
+                std::string buffer;
+
+                if (m_buffer) {
+                    if (m_buffer_size != 0) {
+                        size_t size = m_buffer_size;
+                        m_buffer_size = 0;
+                        buffer.append(m_buffer, size);
+                    }
+                } else {
+                    buffer.resize(osmium::io::Decompressor::input_buffer_size);
+                    auto nread = ::read(m_fd, const_cast<char*>(buffer.data()), osmium::io::Decompressor::input_buffer_size);
+                    if (nread < 0) {
+                        throw std::system_error(errno, std::system_category(), "Read failed");
+                    }
+                    buffer.resize(std::string::size_type(nread));
+                }
+
+                return buffer;
+            }
+
+            void close() final {
+                if (m_fd >= 0) {
+                    int fd = m_fd;
+                    m_fd = -1;
+                    osmium::io::detail::reliable_close(fd);
+                }
+            }
+
+        }; // class NoDecompressor
+
+        namespace detail {
+
+            // we want the register_compression() function to run, setting
+            // the variable is only a side-effect, it will never be used
+            const bool registered_no_compression = osmium::io::CompressionFactory::instance().register_compression(osmium::io::file_compression::none,
+                [](int fd, fsync sync) { return new osmium::io::NoCompressor(fd, sync); },
+                [](int fd) { return new osmium::io::NoDecompressor(fd); },
+                [](const char* buffer, size_t size) { return new osmium::io::NoDecompressor(buffer, size); }
+            );
+
+            // dummy function to silence the unused variable warning from above
+            inline bool get_registered_no_compression() noexcept {
+                return registered_no_compression;
+            }
+
+        } // namespace detail
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_COMPRESSION_HPP

third_party/libosmium/include/osmium/io/debug_output.hpp

@@ -0,0 +1,39 @@
+#ifndef OSMIUM_IO_DEBUG_OUTPUT_HPP
+#define OSMIUM_IO_DEBUG_OUTPUT_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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/io/writer.hpp> // IWYU pragma: export
+#include <osmium/io/detail/debug_output_format.hpp> // IWYU pragma: export
+
+#endif // OSMIUM_IO_DEBUG_OUTPUT_HPP

third_party/libosmium/include/osmium/io/detail/debug_output_format.hpp

@@ -0,0 +1,485 @@
+#ifndef OSMIUM_IO_DETAIL_DEBUG_OUTPUT_FORMAT_HPP
+#define OSMIUM_IO_DETAIL_DEBUG_OUTPUT_FORMAT_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <cinttypes>
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <future>
+#include <iterator>
+#include <memory>
+#include <string>
+#include <thread>
+#include <utility>
+
+#include <osmium/io/detail/output_format.hpp>
+#include <osmium/io/file_format.hpp>
+#include <osmium/memory/buffer.hpp>
+#include <osmium/memory/collection.hpp>
+#include <osmium/osm/box.hpp>
+#include <osmium/osm/changeset.hpp>
+#include <osmium/osm/item_type.hpp>
+#include <osmium/osm/location.hpp>
+#include <osmium/osm/node.hpp>
+#include <osmium/osm/object.hpp>
+#include <osmium/osm/relation.hpp>
+#include <osmium/osm/tag.hpp>
+#include <osmium/osm/timestamp.hpp>
+#include <osmium/osm/way.hpp>
+#include <osmium/thread/pool.hpp>
+#include <osmium/util/minmax.hpp>
+#include <osmium/visitor.hpp>
+
+namespace osmium {
+
+    namespace io {
+
+        class File;
+
+        namespace detail {
+
+            constexpr const char* color_bold    = "\x1b[1m";
+            constexpr const char* color_black   = "\x1b[30m";
+            constexpr const char* color_gray    = "\x1b[30;1m";
+            constexpr const char* color_red     = "\x1b[31m";
+            constexpr const char* color_green   = "\x1b[32m";
+            constexpr const char* color_yellow  = "\x1b[33m";
+            constexpr const char* color_blue    = "\x1b[34m";
+            constexpr const char* color_magenta = "\x1b[35m";
+            constexpr const char* color_cyan    = "\x1b[36m";
+            constexpr const char* color_white   = "\x1b[37m";
+            constexpr const char* color_reset   = "\x1b[0m";
+
+            struct debug_output_options {
+
+                /// Should metadata of objects be added?
+                bool add_metadata;
+
+                /// Output with ANSI colors?
+                bool use_color;
+
+            };
+
+            /**
+             * Writes out one buffer with OSM data in Debug format.
+             */
+            class DebugOutputBlock : public OutputBlock {
+
+                debug_output_options m_options;
+
+                const char* m_utf8_prefix = "";
+                const char* m_utf8_suffix = "";
+
+                void append_encoded_string(const char* data) {
+                    append_debug_encoded_string(*m_out, data, m_utf8_prefix, m_utf8_suffix);
+                }
+
+                void write_color(const char* color) {
+                    if (m_options.use_color) {
+                        *m_out += color;
+                    }
+                }
+
+                void write_string(const char* string) {
+                    *m_out += '"';
+                    write_color(color_blue);
+                    append_encoded_string(string);
+                    write_color(color_reset);
+                    *m_out += '"';
+                }
+
+                void write_object_type(const char* object_type, bool visible = true) {
+                    if (visible) {
+                        write_color(color_bold);
+                    } else {
+                        write_color(color_white);
+                    }
+                    *m_out += object_type;
+                    write_color(color_reset);
+                    *m_out += ' ';
+                }
+
+                void write_fieldname(const char* name) {
+                    *m_out += "  ";
+                    write_color(color_cyan);
+                    *m_out += name;
+                    write_color(color_reset);
+                    *m_out += ": ";
+                }
+
+                void write_comment_field(const char* name) {
+                    write_color(color_cyan);
+                    *m_out += name;
+                    write_color(color_reset);
+                    *m_out += ": ";
+                }
+
+                void write_counter(int width, int n) {
+                    write_color(color_white);
+                    output_formatted("    %0*d: ", width, n++);
+                    write_color(color_reset);
+                }
+
+                void write_error(const char* msg) {
+                    write_color(color_red);
+                    *m_out += msg;
+                    write_color(color_reset);
+                }
+
+                void write_timestamp(const osmium::Timestamp& timestamp) {
+                    if (timestamp.valid()) {
+                        *m_out += timestamp.to_iso();
+                        output_formatted(" (%d)", timestamp.seconds_since_epoch());
+                    } else {
+                        write_error("NOT SET");
+                    }
+                    *m_out += '\n';
+                }
+
+                void write_meta(const osmium::OSMObject& object) {
+                    output_formatted("%" PRId64 "\n", object.id());
+                    if (m_options.add_metadata) {
+                        write_fieldname("version");
+                        output_formatted("  %d", object.version());
+                        if (object.visible()) {
+                            *m_out += " visible\n";
+                        } else {
+                            write_error(" deleted\n");
+                        }
+                        write_fieldname("changeset");
+                        output_formatted("%d\n", object.changeset());
+                        write_fieldname("timestamp");
+                        write_timestamp(object.timestamp());
+                        write_fieldname("user");
+                        output_formatted("     %d ", object.uid());
+                        write_string(object.user());
+                        *m_out += '\n';
+                    }
+                }
+
+                void write_tags(const osmium::TagList& tags, const char* padding="") {
+                    if (!tags.empty()) {
+                        write_fieldname("tags");
+                        *m_out += padding;
+                        output_formatted("     %d\n", tags.size());
+
+                        osmium::max_op<size_t> max;
+                        for (const auto& tag : tags) {
+                            max.update(std::strlen(tag.key()));
+                        }
+                        for (const auto& tag : tags) {
+                            *m_out += "    ";
+                            write_string(tag.key());
+                            auto spacing = max() - std::strlen(tag.key());
+                            while (spacing--) {
+                                *m_out += " ";
+                            }
+                            *m_out += " = ";
+                            write_string(tag.value());
+                            *m_out += '\n';
+                        }
+                    }
+                }
+
+                void write_location(const osmium::Location& location) {
+                    write_fieldname("lon/lat");
+                    output_formatted("  %.7f,%.7f", location.lon_without_check(), location.lat_without_check());
+                    if (!location.valid()) {
+                        write_error(" INVALID LOCATION!");
+                    }
+                    *m_out += '\n';
+                }
+
+                void write_box(const osmium::Box& box) {
+                    write_fieldname("box l/b/r/t");
+                    if (!box) {
+                        write_error("BOX NOT SET!\n");
+                        return;
+                    }
+                    const auto& bl = box.bottom_left();
+                    const auto& tr = box.top_right();
+                    output_formatted("%.7f,%.7f %.7f,%.7f", bl.lon_without_check(), bl.lat_without_check(), tr.lon_without_check(), tr.lat_without_check());
+                    if (!box.valid()) {
+                        write_error(" INVALID BOX!");
+                    }
+                    *m_out += '\n';
+                }
+
+            public:
+
+                DebugOutputBlock(osmium::memory::Buffer&& buffer, const debug_output_options& options) :
+                    OutputBlock(std::move(buffer)),
+                    m_options(options),
+                    m_utf8_prefix(options.use_color ? color_red  : ""),
+                    m_utf8_suffix(options.use_color ? color_blue : "") {
+                }
+
+                DebugOutputBlock(const DebugOutputBlock&) = default;
+                DebugOutputBlock& operator=(const DebugOutputBlock&) = default;
+
+                DebugOutputBlock(DebugOutputBlock&&) = default;
+                DebugOutputBlock& operator=(DebugOutputBlock&&) = default;
+
+                ~DebugOutputBlock() noexcept = default;
+
+                std::string operator()() {
+                    osmium::apply(m_input_buffer->cbegin(), m_input_buffer->cend(), *this);
+
+                    std::string out;
+                    using std::swap;
+                    swap(out, *m_out);
+
+                    return out;
+                }
+
+                void node(const osmium::Node& node) {
+                    write_object_type("node", node.visible());
+                    write_meta(node);
+
+                    if (node.visible()) {
+                        write_location(node.location());
+                    }
+
+                    write_tags(node.tags());
+
+                    *m_out += '\n';
+                }
+
+                void way(const osmium::Way& way) {
+                    write_object_type("way", way.visible());
+                    write_meta(way);
+                    write_tags(way.tags());
+
+                    write_fieldname("nodes");
+
+                    output_formatted("    %d", way.nodes().size());
+                    if (way.nodes().size() < 2) {
+                        write_error(" LESS THAN 2 NODES!\n");
+                    } else if (way.nodes().size() > 2000) {
+                        write_error(" MORE THAN 2000 NODES!\n");
+                    } else if (way.nodes().is_closed()) {
+                        *m_out += " (closed)\n";
+                    } else {
+                        *m_out += " (open)\n";
+                    }
+
+                    int width = int(log10(way.nodes().size())) + 1;
+                    int n = 0;
+                    for (const auto& node_ref : way.nodes()) {
+                        write_counter(width, n++);
+                        output_formatted("%10" PRId64, node_ref.ref());
+                        if (node_ref.location().valid()) {
+                            output_formatted(" (%.7f,%.7f)", node_ref.location().lon_without_check(), node_ref.location().lat_without_check());
+                        }
+                        *m_out += '\n';
+                    }
+
+                    *m_out += '\n';
+                }
+
+                void relation(const osmium::Relation& relation) {
+                    static const char* short_typename[] = { "node", "way ", "rel " };
+                    write_object_type("relation", relation.visible());
+                    write_meta(relation);
+                    write_tags(relation.tags());
+
+                    write_fieldname("members");
+                    output_formatted("  %d\n", relation.members().size());
+
+                    int width = int(log10(relation.members().size())) + 1;
+                    int n = 0;
+                    for (const auto& member : relation.members()) {
+                        write_counter(width, n++);
+                        *m_out += short_typename[item_type_to_nwr_index(member.type())];
+                        output_formatted(" %10" PRId64 " ", member.ref());
+                        write_string(member.role());
+                        *m_out += '\n';
+                    }
+
+                    *m_out += '\n';
+                }
+
+                void changeset(const osmium::Changeset& changeset) {
+                    write_object_type("changeset");
+                    output_formatted("%d\n", changeset.id());
+
+                    write_fieldname("num changes");
+                    output_formatted("%d", changeset.num_changes());
+                    if (changeset.num_changes() == 0) {
+                        write_error(" NO CHANGES!");
+                    }
+                    *m_out += '\n';
+
+                    write_fieldname("created at");
+                    *m_out += ' ';
+                    write_timestamp(changeset.created_at());
+
+                    write_fieldname("closed at");
+                    *m_out += "  ";
+                    if (changeset.closed()) {
+                        write_timestamp(changeset.closed_at());
+                    } else {
+                        write_error("OPEN!\n");
+                    }
+
+                    write_fieldname("user");
+                    output_formatted("       %d ", changeset.uid());
+                    write_string(changeset.user());
+                    *m_out += '\n';
+
+                    write_box(changeset.bounds());
+                    write_tags(changeset.tags(), "  ");
+
+                    if (changeset.num_comments() > 0) {
+                        write_fieldname("comments");
+                        output_formatted("   %d\n", changeset.num_comments());
+
+                        int width = int(log10(changeset.num_comments())) + 1;
+                        int n = 0;
+                        for (const auto& comment : changeset.discussion()) {
+                            write_counter(width, n++);
+
+                            write_comment_field("date");
+                            write_timestamp(comment.date());
+                            output_formatted("      %*s", width, "");
+
+                            write_comment_field("user");
+                            output_formatted("%d ", comment.uid());
+                            write_string(comment.user());
+                            output_formatted("\n      %*s", width, "");
+
+                            write_comment_field("text");
+                            write_string(comment.text());
+                            *m_out += '\n';
+                        }
+                    }
+
+                    *m_out += '\n';
+                }
+
+            }; // class DebugOutputBlock
+
+            class DebugOutputFormat : public osmium::io::detail::OutputFormat {
+
+                debug_output_options m_options;
+
+                void write_fieldname(std::string& out, const char* name) {
+                    out += "  ";
+                    if (m_options.use_color) {
+                        out += color_cyan;
+                    }
+                    out += name;
+                    if (m_options.use_color) {
+                        out += color_reset;
+                    }
+                    out += ": ";
+                }
+
+            public:
+
+                DebugOutputFormat(const osmium::io::File& file, future_string_queue_type& output_queue) :
+                    OutputFormat(output_queue),
+                    m_options() {
+                    m_options.add_metadata = file.is_not_false("add_metadata");
+                    m_options.use_color    = file.is_true("color");
+                }
+
+                DebugOutputFormat(const DebugOutputFormat&) = delete;
+                DebugOutputFormat& operator=(const DebugOutputFormat&) = delete;
+
+                ~DebugOutputFormat() noexcept final = default;
+
+                void write_header(const osmium::io::Header& header) final {
+                    std::string out;
+
+                    if (m_options.use_color) {
+                        out += color_bold;
+                    }
+                    out += "header\n";
+                    if (m_options.use_color) {
+                        out += color_reset;
+                    }
+
+                    write_fieldname(out, "multiple object versions");
+                    out += header.has_multiple_object_versions() ? "yes" : "no";
+                    out += '\n';
+                    write_fieldname(out, "bounding boxes");
+                    out += '\n';
+                    for (const auto& box : header.boxes()) {
+                        out += "    ";
+                        box.bottom_left().as_string(std::back_inserter(out), ',');
+                        out += " ";
+                        box.top_right().as_string(std::back_inserter(out), ',');
+                        out += '\n';
+                    }
+                    write_fieldname(out, "options");
+                    out += '\n';
+                    for (const auto& opt : header) {
+                        out += "    ";
+                        out += opt.first;
+                        out += " = ";
+                        out += opt.second;
+                        out += '\n';
+                    }
+                    out += "\n=============================================\n\n";
+
+                    send_to_output_queue(std::move(out));
+                }
+
+                void write_buffer(osmium::memory::Buffer&& buffer) final {
+                    m_output_queue.push(osmium::thread::Pool::instance().submit(DebugOutputBlock{std::move(buffer), m_options}));
+                }
+
+            }; // class DebugOutputFormat
+
+            // we want the register_output_format() function to run, setting
+            // the variable is only a side-effect, it will never be used
+            const bool registered_debug_output = osmium::io::detail::OutputFormatFactory::instance().register_output_format(osmium::io::file_format::debug,
+                [](const osmium::io::File& file, future_string_queue_type& output_queue) {
+                    return new osmium::io::detail::DebugOutputFormat(file, output_queue);
+            });
+
+            // dummy function to silence the unused variable warning from above
+            inline bool get_registered_debug_output() noexcept {
+                return registered_debug_output;
+            }
+
+        } // namespace detail
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_DETAIL_DEBUG_OUTPUT_FORMAT_HPP

third_party/libosmium/include/osmium/io/detail/input_format.hpp

@@ -0,0 +1,211 @@
+#ifndef OSMIUM_IO_DETAIL_INPUT_FORMAT_HPP
+#define OSMIUM_IO_DETAIL_INPUT_FORMAT_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <exception>
+#include <functional>
+#include <future>
+#include <map>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <utility>
+
+#include <osmium/io/detail/queue_util.hpp>
+#include <osmium/io/file.hpp>
+#include <osmium/io/file_format.hpp>
+#include <osmium/io/header.hpp>
+#include <osmium/memory/buffer.hpp>
+#include <osmium/osm/entity_bits.hpp>
+
+namespace osmium {
+
+    namespace io {
+
+        namespace detail {
+
+            class Parser {
+
+                future_buffer_queue_type& m_output_queue;
+                std::promise<osmium::io::Header>& m_header_promise;
+                queue_wrapper<std::string> m_input_queue;
+                osmium::osm_entity_bits::type m_read_types;
+                bool m_header_is_done;
+
+            protected:
+
+                std::string get_input() {
+                    return m_input_queue.pop();
+                }
+
+                bool input_done() const {
+                    return m_input_queue.has_reached_end_of_data();
+                }
+
+                osmium::osm_entity_bits::type read_types() const {
+                    return m_read_types;
+                }
+
+                bool header_is_done() const {
+                    return m_header_is_done;
+                }
+
+                void set_header_value(const osmium::io::Header& header) {
+                    if (!m_header_is_done) {
+                        m_header_is_done = true;
+                        m_header_promise.set_value(header);
+                    }
+                }
+
+                void set_header_exception(const std::exception_ptr& exception) {
+                    if (!m_header_is_done) {
+                        m_header_is_done = true;
+                        m_header_promise.set_exception(exception);
+                    }
+                }
+
+                /**
+                 * Wrap the buffer into a future and add it to the output queue.
+                 */
+                void send_to_output_queue(osmium::memory::Buffer&& buffer) {
+                    add_to_queue(m_output_queue, std::move(buffer));
+                }
+
+                void send_to_output_queue(std::future<osmium::memory::Buffer>&& future) {
+                    m_output_queue.push(std::move(future));
+                }
+
+            public:
+
+                Parser(future_string_queue_type& input_queue,
+                       future_buffer_queue_type& output_queue,
+                       std::promise<osmium::io::Header>& header_promise,
+                       osmium::osm_entity_bits::type read_types) :
+                    m_output_queue(output_queue),
+                    m_header_promise(header_promise),
+                    m_input_queue(input_queue),
+                    m_read_types(read_types),
+                    m_header_is_done(false) {
+                }
+
+                Parser(const Parser&) = delete;
+                Parser& operator=(const Parser&) = delete;
+
+                Parser(Parser&&) = delete;
+                Parser& operator=(Parser&&) = delete;
+
+                virtual ~Parser() noexcept = default;
+
+                virtual void run() = 0;
+
+                void parse() {
+                    try {
+                        run();
+                    } catch (...) {
+                        std::exception_ptr exception = std::current_exception();
+                        set_header_exception(exception);
+                        add_to_queue(m_output_queue, std::move(exception));
+                    }
+
+                    add_end_of_data_to_queue(m_output_queue);
+                }
+
+            }; // class Parser
+
+            /**
+             * This factory class is used to create objects that decode OSM
+             * data written in a specified format.
+             *
+             * Do not use this class directly. Use the osmium::io::Reader
+             * class instead.
+             */
+            class ParserFactory {
+
+            public:
+
+                typedef std::function<
+                            std::unique_ptr<Parser>(
+                                future_string_queue_type&,
+                                future_buffer_queue_type&,
+                                std::promise<osmium::io::Header>& header_promise,
+                                osmium::osm_entity_bits::type read_which_entities
+                            )
+                        > create_parser_type;
+
+            private:
+
+                typedef std::map<osmium::io::file_format, create_parser_type> map_type;
+
+                map_type m_callbacks;
+
+                ParserFactory() :
+                    m_callbacks() {
+                }
+
+            public:
+
+                static ParserFactory& instance() {
+                    static ParserFactory factory;
+                    return factory;
+                }
+
+                bool register_parser(osmium::io::file_format format, create_parser_type create_function) {
+                    if (! m_callbacks.insert(map_type::value_type(format, create_function)).second) {
+                        return false;
+                    }
+                    return true;
+                }
+
+                create_parser_type get_creator_function(const osmium::io::File& file) {
+                    auto it = m_callbacks.find(file.format());
+                    if (it == m_callbacks.end()) {
+                        throw unsupported_file_format_error(
+                                std::string("Can not open file '") +
+                                file.filename() +
+                                "' with type '" +
+                                as_string(file.format()) +
+                                "'. No support for reading this format in this program.");
+                    }
+                    return it->second;
+                }
+
+            }; // class ParserFactory
+
+        } // namespace detail
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_DETAIL_INPUT_FORMAT_HPP

third_party/libosmium/include/osmium/io/detail/o5m_input_format.hpp

@@ -0,0 +1,636 @@
+#ifndef OSMIUM_IO_DETAIL_O5M_INPUT_FORMAT_HPP
+#define OSMIUM_IO_DETAIL_O5M_INPUT_FORMAT_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <future>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include <protozero/varint.hpp>
+
+#include <osmium/builder/builder.hpp>
+#include <osmium/builder/osm_object_builder.hpp>
+#include <osmium/io/detail/input_format.hpp>
+#include <osmium/io/detail/queue_util.hpp>
+#include <osmium/io/error.hpp>
+#include <osmium/io/file_format.hpp>
+#include <osmium/io/header.hpp>
+#include <osmium/memory/buffer.hpp>
+#include <osmium/osm.hpp>
+#include <osmium/osm/box.hpp>
+#include <osmium/osm/entity_bits.hpp>
+#include <osmium/osm/item_type.hpp>
+#include <osmium/osm/location.hpp>
+#include <osmium/osm/object.hpp>
+#include <osmium/osm/types.hpp>
+#include <osmium/thread/util.hpp>
+#include <osmium/util/cast.hpp>
+#include <osmium/util/delta.hpp>
+
+namespace osmium {
+
+    /**
+     * Exception thrown when the o5m deocder failed. The exception contains
+     * (if available) information about the place where the error happened
+     * and the type of error.
+     */
+    struct o5m_error : public io_error {
+
+        explicit o5m_error(const char* what) :
+            io_error(std::string("o5m format error: ") + what) {
+        }
+
+    }; // struct o5m_error
+
+    namespace io {
+
+        namespace detail {
+
+            // Implementation of the o5m/o5c file formats according to the
+            // description at http://wiki.openstreetmap.org/wiki/O5m .
+
+            class ReferenceTable {
+
+                // The following settings are from the o5m description:
+
+                // The maximum number of entries in this table.
+                const uint64_t number_of_entries = 15000;
+
+                // The size of one entry in the table.
+                const unsigned int entry_size = 256;
+
+                // The maximum length of a string in the table including
+                // two \0 bytes.
+                const unsigned int max_length = 250 + 2;
+
+                // The data is stored in this string. It is default constructed
+                // and then resized on demand the first time something is added.
+                // This is done because the ReferenceTable is in a O5mParser
+                // object which will be copied from one thread to another. This
+                // way the string is still small when it is copied.
+                std::string m_table;
+
+                unsigned int current_entry = 0;
+
+            public:
+
+                void clear() {
+                    current_entry = 0;
+                }
+
+                void add(const char* string, size_t size) {
+                    if (m_table.empty()) {
+                        m_table.resize(entry_size * number_of_entries);
+                    }
+                    if (size <= max_length) {
+                        std::copy_n(string, size, &m_table[current_entry * entry_size]);
+                        if (++current_entry == number_of_entries) {
+                            current_entry = 0;
+                        }
+                    }
+                }
+
+                const char* get(uint64_t index) const {
+                    if (m_table.empty() || index == 0 || index > number_of_entries) {
+                        throw o5m_error("reference to non-existing string in table");
+                    }
+                    auto entry = (current_entry + number_of_entries - index) % number_of_entries;
+                    return &m_table[entry * entry_size];
+                }
+
+            }; // class ReferenceTable
+
+            class O5mParser : public Parser {
+
+                static constexpr int buffer_size = 2 * 1000 * 1000;
+
+                osmium::io::Header m_header;
+
+                osmium::memory::Buffer m_buffer;
+
+                std::string m_input;
+
+                const char* m_data;
+                const char* m_end;
+
+                ReferenceTable m_reference_table;
+
+                static int64_t zvarint(const char** data, const char* end) {
+                    return protozero::decode_zigzag64(protozero::decode_varint(data, end));
+                }
+
+                bool ensure_bytes_available(size_t need_bytes) {
+                    if ((m_end - m_data) >= long(need_bytes)) {
+                        return true;
+                    }
+
+                    if (input_done() && (m_input.size() < need_bytes)) {
+                        return false;
+                    }
+
+                    m_input.erase(0, m_data - m_input.data());
+
+                    while (m_input.size() < need_bytes) {
+                        std::string data = get_input();
+                        if (input_done()) {
+                            return false;
+                        }
+                        m_input.append(data);
+                    }
+
+                    m_data = m_input.data();
+                    m_end = m_input.data() + m_input.size();
+
+                    return true;
+                }
+
+                void check_header_magic() {
+                    static const unsigned char header_magic[] = { 0xff, 0xe0, 0x04, 'o', '5' };
+
+                    if (std::strncmp(reinterpret_cast<const char*>(header_magic), m_data, sizeof(header_magic))) {
+                        throw o5m_error("wrong header magic");
+                    }
+
+                    m_data += sizeof(header_magic);
+                }
+
+                void check_file_type() {
+                    if (*m_data == 'm') {         // o5m data file
+                        m_header.set_has_multiple_object_versions(false);
+                    } else if (*m_data == 'c') {  // o5c change file
+                        m_header.set_has_multiple_object_versions(true);
+                    } else {
+                        throw o5m_error("wrong header magic");
+                    }
+
+                    m_data++;
+                }
+
+                void check_file_format_version() {
+                    if (*m_data != '2') {
+                        throw o5m_error("wrong header magic");
+                    }
+
+                    m_data++;
+                }
+
+                void decode_header() {
+                    if (! ensure_bytes_available(7)) { // overall length of header
+                        throw o5m_error("file too short (incomplete header info)");
+                    }
+
+                    check_header_magic();
+                    check_file_type();
+                    check_file_format_version();
+                }
+
+                void mark_header_as_done() {
+                    set_header_value(m_header);
+                }
+
+                osmium::util::DeltaDecode<osmium::object_id_type> m_delta_id;
+
+                osmium::util::DeltaDecode<int64_t> m_delta_timestamp;
+                osmium::util::DeltaDecode<osmium::changeset_id_type> m_delta_changeset;
+                osmium::util::DeltaDecode<int64_t> m_delta_lon;
+                osmium::util::DeltaDecode<int64_t> m_delta_lat;
+
+                osmium::util::DeltaDecode<osmium::object_id_type> m_delta_way_node_id;
+                osmium::util::DeltaDecode<osmium::object_id_type> m_delta_member_ids[3];
+
+                void reset() {
+                    m_reference_table.clear();
+
+                    m_delta_id.clear();
+                    m_delta_timestamp.clear();
+                    m_delta_changeset.clear();
+                    m_delta_lon.clear();
+                    m_delta_lat.clear();
+
+                    m_delta_way_node_id.clear();
+                    m_delta_member_ids[0].clear();
+                    m_delta_member_ids[1].clear();
+                    m_delta_member_ids[2].clear();
+                }
+
+                const char* decode_string(const char** dataptr, const char* const end) {
+                    if (**dataptr == 0x00) { // get inline string
+                        (*dataptr)++;
+                        if (*dataptr == end) {
+                            throw o5m_error("string format error");
+                        }
+                        return *dataptr;
+                    } else { // get from reference table
+                        auto index = protozero::decode_varint(dataptr, end);
+                        return m_reference_table.get(index);
+                    }
+                }
+
+                std::pair<osmium::user_id_type, const char*> decode_user(const char** dataptr, const char* const end) {
+                    bool update_pointer = (**dataptr == 0x00);
+                    const char* data = decode_string(dataptr, end);
+                    const char* start = data;
+
+                    auto uid = protozero::decode_varint(&data, end);
+
+                    if (data == end) {
+                        throw o5m_error("missing user name");
+                    }
+
+                    const char* user = ++data;
+
+                    if (uid == 0 && update_pointer) {
+                        m_reference_table.add("\0\0", 2);
+                        *dataptr = data;
+                        return std::make_pair(0, "");
+                    }
+
+                    while (*data++) {
+                        if (data == end) {
+                            throw o5m_error("no null byte in user name");
+                        }
+                    }
+
+                    if (update_pointer) {
+                        m_reference_table.add(start, data - start);
+                        *dataptr = data;
+                    }
+
+                    return std::make_pair(static_cast_with_assert<osmium::user_id_type>(uid), user);
+                }
+
+                void decode_tags(osmium::builder::Builder* builder, const char** dataptr, const char* const end) {
+                    osmium::builder::TagListBuilder tl_builder(m_buffer, builder);
+
+                    while(*dataptr != end) {
+                        bool update_pointer = (**dataptr == 0x00);
+                        const char* data = decode_string(dataptr, end);
+                        const char* start = data;
+
+                        while (*data++) {
+                            if (data == end) {
+                                throw o5m_error("no null byte in tag key");
+                            }
+                        }
+
+                        const char* value = data;
+                        while (*data++) {
+                            if (data == end) {
+                                throw o5m_error("no null byte in tag value");
+                            }
+                        }
+
+                        if (update_pointer) {
+                            m_reference_table.add(start, data - start);
+                            *dataptr = data;
+                        }
+
+                        tl_builder.add_tag(start, value);
+                    }
+                }
+
+                const char* decode_info(osmium::OSMObject& object, const char** dataptr, const char* const end) {
+                    const char* user = "";
+
+                    if (**dataptr == 0x00) { // no info section
+                        ++*dataptr;
+                    } else { // has info section
+                        object.set_version(static_cast_with_assert<object_version_type>(protozero::decode_varint(dataptr, end)));
+                        auto timestamp = m_delta_timestamp.update(zvarint(dataptr, end));
+                        if (timestamp != 0) { // has timestamp
+                            object.set_timestamp(timestamp);
+                            object.set_changeset(m_delta_changeset.update(zvarint(dataptr, end)));
+                            if (*dataptr != end) {
+                                auto uid_user = decode_user(dataptr, end);
+                                object.set_uid(uid_user.first);
+                                user = uid_user.second;
+                            } else {
+                                object.set_uid(user_id_type(0));
+                            }
+                        }
+                    }
+
+                    return user;
+                }
+
+                void decode_node(const char* data, const char* const end) {
+                    osmium::builder::NodeBuilder builder(m_buffer);
+                    osmium::Node& node = builder.object();
+
+                    node.set_id(m_delta_id.update(zvarint(&data, end)));
+
+                    builder.add_user(decode_info(node, &data, end));
+
+                    if (data == end) {
+                        // no location, object is deleted
+                        builder.object().set_visible(false);
+                        builder.object().set_location(osmium::Location{});
+                    } else {
+                        auto lon = m_delta_lon.update(zvarint(&data, end));
+                        auto lat = m_delta_lat.update(zvarint(&data, end));
+                        builder.object().set_location(osmium::Location{lon, lat});
+
+                        if (data != end) {
+                            decode_tags(&builder, &data, end);
+                        }
+                    }
+
+                    m_buffer.commit();
+                }
+
+                void decode_way(const char* data, const char* const end) {
+                    osmium::builder::WayBuilder builder(m_buffer);
+                    osmium::Way& way = builder.object();
+
+                    way.set_id(m_delta_id.update(zvarint(&data, end)));
+
+                    builder.add_user(decode_info(way, &data, end));
+
+                    if (data == end) {
+                        // no reference section, object is deleted
+                        builder.object().set_visible(false);
+                    } else {
+                        auto reference_section_length = protozero::decode_varint(&data, end);
+                        if (reference_section_length > 0) {
+                            const char* const end_refs = data + reference_section_length;
+                            if (end_refs > end) {
+                                throw o5m_error("way nodes ref section too long");
+                            }
+
+                            osmium::builder::WayNodeListBuilder wn_builder(m_buffer, &builder);
+
+                            while (data < end_refs) {
+                                wn_builder.add_node_ref(m_delta_way_node_id.update(zvarint(&data, end)));
+                            }
+                        }
+
+                        if (data != end) {
+                            decode_tags(&builder, &data, end);
+                        }
+                    }
+
+                    m_buffer.commit();
+                }
+
+                osmium::item_type decode_member_type(char c) {
+                    if (c < '0' || c > '2') {
+                        throw o5m_error("unknown member type");
+                    }
+                    return osmium::nwr_index_to_item_type(c - '0');
+                }
+
+                std::pair<osmium::item_type, const char*> decode_role(const char** dataptr, const char* const end) {
+                    bool update_pointer = (**dataptr == 0x00);
+                    const char* data = decode_string(dataptr, end);
+                    const char* start = data;
+
+                    auto member_type = decode_member_type(*data++);
+                    if (data == end) {
+                        throw o5m_error("missing role");
+                    }
+                    const char* role = data;
+
+                    while (*data++) {
+                        if (data == end) {
+                            throw o5m_error("no null byte in role");
+                        }
+                    }
+
+                    if (update_pointer) {
+                        m_reference_table.add(start, data - start);
+                        *dataptr = data;
+                    }
+
+                    return std::make_pair(member_type, role);
+                }
+
+                void decode_relation(const char* data, const char* const end) {
+                    osmium::builder::RelationBuilder builder(m_buffer);
+                    osmium::Relation& relation = builder.object();
+
+                    relation.set_id(m_delta_id.update(zvarint(&data, end)));
+
+                    builder.add_user(decode_info(relation, &data, end));
+
+                    if (data == end) {
+                        // no reference section, object is deleted
+                        builder.object().set_visible(false);
+                    } else {
+                        auto reference_section_length = protozero::decode_varint(&data, end);
+                        if (reference_section_length > 0) {
+                            const char* const end_refs = data + reference_section_length;
+                            if (end_refs > end) {
+                                throw o5m_error("relation format error");
+                            }
+
+                            osmium::builder::RelationMemberListBuilder rml_builder(m_buffer, &builder);
+
+                            while (data < end_refs) {
+                                auto delta_id = zvarint(&data, end);
+                                if (data == end) {
+                                    throw o5m_error("relation member format error");
+                                }
+                                auto type_role = decode_role(&data, end);
+                                auto i = osmium::item_type_to_nwr_index(type_role.first);
+                                auto ref = m_delta_member_ids[i].update(delta_id);
+                                rml_builder.add_member(type_role.first, ref, type_role.second);
+                            }
+                        }
+
+                        if (data != end) {
+                            decode_tags(&builder, &data, end);
+                        }
+                    }
+
+                    m_buffer.commit();
+                }
+
+                void decode_bbox(const char* data, const char* const end) {
+                    auto sw_lon = zvarint(&data, end);
+                    auto sw_lat = zvarint(&data, end);
+                    auto ne_lon = zvarint(&data, end);
+                    auto ne_lat = zvarint(&data, end);
+
+                    m_header.add_box(osmium::Box{osmium::Location{sw_lon, sw_lat},
+                                                 osmium::Location{ne_lon, ne_lat}});
+                }
+
+                void decode_timestamp(const char* data, const char* const end) {
+                    auto timestamp = osmium::Timestamp(zvarint(&data, end)).to_iso();
+                    m_header.set("o5m_timestamp", timestamp);
+                    m_header.set("timestamp", timestamp);
+                }
+
+                void flush() {
+                    osmium::memory::Buffer buffer(buffer_size);
+                    using std::swap;
+                    swap(m_buffer, buffer);
+                    send_to_output_queue(std::move(buffer));
+                }
+
+                enum class dataset_type : unsigned char {
+                    node         = 0x10,
+                    way          = 0x11,
+                    relation     = 0x12,
+                    bounding_box = 0xdb,
+                    timestamp    = 0xdc,
+                    header       = 0xe0,
+                    sync         = 0xee,
+                    jump         = 0xef,
+                    reset        = 0xff
+                };
+
+                void decode_data() {
+                    while (ensure_bytes_available(1)) {
+                        dataset_type ds_type = dataset_type(*m_data++);
+                        if (ds_type > dataset_type::jump) {
+                            if (ds_type == dataset_type::reset) {
+                                reset();
+                            }
+                        } else {
+                            ensure_bytes_available(protozero::max_varint_length);
+
+                            uint64_t length = 0;
+                            try {
+                                length = protozero::decode_varint(&m_data, m_end);
+                            } catch (protozero::end_of_buffer_exception&) {
+                                throw o5m_error("premature end of file");
+                            }
+
+                            if (! ensure_bytes_available(length)) {
+                                throw o5m_error("premature end of file");
+                            }
+
+                            switch (ds_type) {
+                                case dataset_type::node:
+                                    mark_header_as_done();
+                                    if (read_types() & osmium::osm_entity_bits::node) {
+                                        decode_node(m_data, m_data + length);
+                                    }
+                                    break;
+                                case dataset_type::way:
+                                    mark_header_as_done();
+                                    if (read_types() & osmium::osm_entity_bits::way) {
+                                        decode_way(m_data, m_data + length);
+                                    }
+                                    break;
+                                case dataset_type::relation:
+                                    mark_header_as_done();
+                                    if (read_types() & osmium::osm_entity_bits::relation) {
+                                        decode_relation(m_data, m_data + length);
+                                    }
+                                    break;
+                                case dataset_type::bounding_box:
+                                    decode_bbox(m_data, m_data + length);
+                                    break;
+                                case dataset_type::timestamp:
+                                    decode_timestamp(m_data, m_data + length);
+                                    break;
+                                default:
+                                    // ignore unknown datasets
+                                    break;
+                            }
+
+                            if (read_types() == osmium::osm_entity_bits::nothing && header_is_done()) {
+                                break;
+                            }
+
+                            m_data += length;
+
+                            if (m_buffer.committed() > buffer_size / 10 * 9) {
+                                flush();
+                            }
+                        }
+                    }
+
+                    if (m_buffer.committed()) {
+                        flush();
+                    }
+
+                    mark_header_as_done();
+                }
+
+            public:
+
+                O5mParser(future_string_queue_type& input_queue,
+                          future_buffer_queue_type& output_queue,
+                          std::promise<osmium::io::Header>& header_promise,
+                          osmium::osm_entity_bits::type read_types) :
+                    Parser(input_queue, output_queue, header_promise, read_types),
+                    m_header(),
+                    m_buffer(buffer_size),
+                    m_input(),
+                    m_data(m_input.data()),
+                    m_end(m_data) {
+                }
+
+                ~O5mParser() noexcept final = default;
+
+                void run() final {
+                    osmium::thread::set_thread_name("_osmium_o5m_in");
+
+                    decode_header();
+                    decode_data();
+                }
+
+            }; // class O5mParser
+
+            // we want the register_parser() function to run, setting
+            // the variable is only a side-effect, it will never be used
+            const bool registered_o5m_parser = ParserFactory::instance().register_parser(
+                file_format::o5m,
+                [](future_string_queue_type& input_queue,
+                    future_buffer_queue_type& output_queue,
+                    std::promise<osmium::io::Header>& header_promise,
+                    osmium::osm_entity_bits::type read_which_entities) {
+                    return std::unique_ptr<Parser>(new O5mParser(input_queue, output_queue, header_promise, read_which_entities));
+            });
+
+            // dummy function to silence the unused variable warning from above
+            inline bool get_registered_o5m_parser() noexcept {
+                return registered_o5m_parser;
+            }
+
+        } // namespace detail
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_DETAIL_O5M_INPUT_FORMAT_HPP

third_party/libosmium/include/osmium/io/detail/opl_output_format.hpp

@@ -0,0 +1,261 @@
+#ifndef OSMIUM_IO_DETAIL_OPL_OUTPUT_FORMAT_HPP
+#define OSMIUM_IO_DETAIL_OPL_OUTPUT_FORMAT_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <cinttypes>
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <future>
+#include <iterator>
+#include <memory>
+#include <string>
+#include <thread>
+#include <utility>
+
+#include <osmium/io/detail/output_format.hpp>
+#include <osmium/io/file_format.hpp>
+#include <osmium/memory/buffer.hpp>
+#include <osmium/memory/collection.hpp>
+#include <osmium/osm/box.hpp>
+#include <osmium/osm/changeset.hpp>
+#include <osmium/osm/item_type.hpp>
+#include <osmium/osm/location.hpp>
+#include <osmium/osm/node.hpp>
+#include <osmium/osm/object.hpp>
+#include <osmium/osm/relation.hpp>
+#include <osmium/osm/tag.hpp>
+#include <osmium/osm/timestamp.hpp>
+#include <osmium/osm/way.hpp>
+#include <osmium/thread/pool.hpp>
+#include <osmium/visitor.hpp>
+
+namespace osmium {
+
+    namespace io {
+
+        class File;
+
+        namespace detail {
+
+            struct opl_output_options {
+
+                /// Should metadata of objects be added?
+                bool add_metadata;
+
+            };
+
+            /**
+             * Writes out one buffer with OSM data in OPL format.
+             */
+            class OPLOutputBlock : public OutputBlock {
+
+                opl_output_options m_options;
+
+                void append_encoded_string(const char* data) {
+                    osmium::io::detail::append_utf8_encoded_string(*m_out, data);
+                }
+
+                void write_meta(const osmium::OSMObject& object) {
+                    output_formatted("%" PRId64, object.id());
+                    if (m_options.add_metadata) {
+                        output_formatted(" v%d d", object.version());
+                        *m_out += (object.visible() ? 'V' : 'D');
+                        output_formatted(" c%d t", object.changeset());
+                        *m_out += object.timestamp().to_iso();
+                        output_formatted(" i%d u", object.uid());
+                        append_encoded_string(object.user());
+                    }
+                    *m_out += " T";
+                    bool first = true;
+                    for (const auto& tag : object.tags()) {
+                        if (first) {
+                            first = false;
+                        } else {
+                            *m_out += ',';
+                        }
+                        append_encoded_string(tag.key());
+                        *m_out += '=';
+                        append_encoded_string(tag.value());
+                    }
+                }
+
+                void write_location(const osmium::Location& location, const char x, const char y) {
+                    if (location) {
+                        output_formatted(" %c%.7f %c%.7f", x, location.lon_without_check(), y, location.lat_without_check());
+                    } else {
+                        *m_out += ' ';
+                        *m_out += x;
+                        *m_out += ' ';
+                        *m_out += y;
+                    }
+                }
+
+            public:
+
+                OPLOutputBlock(osmium::memory::Buffer&& buffer, const opl_output_options& options) :
+                    OutputBlock(std::move(buffer)),
+                    m_options(options) {
+                }
+
+                OPLOutputBlock(const OPLOutputBlock&) = default;
+                OPLOutputBlock& operator=(const OPLOutputBlock&) = default;
+
+                OPLOutputBlock(OPLOutputBlock&&) = default;
+                OPLOutputBlock& operator=(OPLOutputBlock&&) = default;
+
+                ~OPLOutputBlock() noexcept = default;
+
+                std::string operator()() {
+                    osmium::apply(m_input_buffer->cbegin(), m_input_buffer->cend(), *this);
+
+                    std::string out;
+                    using std::swap;
+                    swap(out, *m_out);
+
+                    return out;
+                }
+
+                void node(const osmium::Node& node) {
+                    *m_out += 'n';
+                    write_meta(node);
+                    write_location(node.location(), 'x', 'y');
+                    *m_out += '\n';
+                }
+
+                void way(const osmium::Way& way) {
+                    *m_out += 'w';
+                    write_meta(way);
+
+                    *m_out += " N";
+                    bool first = true;
+                    for (const auto& node_ref : way.nodes()) {
+                        if (first) {
+                            first = false;
+                        } else {
+                            *m_out += ',';
+                        }
+                        output_formatted("n%" PRId64, node_ref.ref());
+                    }
+                    *m_out += '\n';
+                }
+
+                void relation(const osmium::Relation& relation) {
+                    *m_out += 'r';
+                    write_meta(relation);
+
+                    *m_out += " M";
+                    bool first = true;
+                    for (const auto& member : relation.members()) {
+                        if (first) {
+                            first = false;
+                        } else {
+                            *m_out += ',';
+                        }
+                        *m_out += item_type_to_char(member.type());
+                        output_formatted("%" PRId64 "@", member.ref());
+                        append_encoded_string(member.role());
+                    }
+                    *m_out += '\n';
+                }
+
+                void changeset(const osmium::Changeset& changeset) {
+                    output_formatted("c%d k%d s", changeset.id(), changeset.num_changes());
+                    *m_out += changeset.created_at().to_iso();
+                    *m_out += " e";
+                    *m_out += changeset.closed_at().to_iso();
+                    output_formatted(" d%d i%d u", changeset.num_comments(), changeset.uid());
+                    append_encoded_string(changeset.user());
+                    write_location(changeset.bounds().bottom_left(), 'x', 'y');
+                    write_location(changeset.bounds().top_right(), 'X', 'Y');
+                    *m_out += " T";
+                    bool first = true;
+                    for (const auto& tag : changeset.tags()) {
+                        if (first) {
+                            first = false;
+                        } else {
+                            *m_out += ',';
+                        }
+                        append_encoded_string(tag.key());
+                        *m_out += '=';
+                        append_encoded_string(tag.value());
+                    }
+
+                    *m_out += '\n';
+                }
+
+            }; // class OPLOutputBlock
+
+            class OPLOutputFormat : public osmium::io::detail::OutputFormat {
+
+                opl_output_options m_options;
+
+            public:
+
+                OPLOutputFormat(const osmium::io::File& file, future_string_queue_type& output_queue) :
+                    OutputFormat(output_queue),
+                    m_options() {
+                    m_options.add_metadata = file.is_not_false("add_metadata");
+                }
+
+                OPLOutputFormat(const OPLOutputFormat&) = delete;
+                OPLOutputFormat& operator=(const OPLOutputFormat&) = delete;
+
+                ~OPLOutputFormat() noexcept final = default;
+
+                void write_buffer(osmium::memory::Buffer&& buffer) final {
+                    m_output_queue.push(osmium::thread::Pool::instance().submit(OPLOutputBlock{std::move(buffer), m_options}));
+                }
+
+            }; // class OPLOutputFormat
+
+            // we want the register_output_format() function to run, setting
+            // the variable is only a side-effect, it will never be used
+            const bool registered_opl_output = osmium::io::detail::OutputFormatFactory::instance().register_output_format(osmium::io::file_format::opl,
+                [](const osmium::io::File& file, future_string_queue_type& output_queue) {
+                    return new osmium::io::detail::OPLOutputFormat(file, output_queue);
+            });
+
+            // dummy function to silence the unused variable warning from above
+            inline bool get_registered_opl_output() noexcept {
+                return registered_opl_output;
+            }
+
+        } // namespace detail
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_DETAIL_OPL_OUTPUT_FORMAT_HPP

third_party/libosmium/include/osmium/io/detail/output_format.hpp

@@ -0,0 +1,184 @@
+#ifndef OSMIUM_IO_DETAIL_OUTPUT_FORMAT_HPP
+#define OSMIUM_IO_DETAIL_OUTPUT_FORMAT_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <functional>
+#include <map>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <utility>
+
+#include <osmium/handler.hpp>
+#include <osmium/io/detail/queue_util.hpp>
+#include <osmium/io/detail/string_util.hpp>
+#include <osmium/io/file.hpp>
+#include <osmium/io/file_format.hpp>
+#include <osmium/memory/buffer.hpp>
+
+namespace osmium {
+
+    namespace io {
+        class Header;
+    } // namespace io
+
+    namespace io {
+
+        namespace detail {
+
+            class OutputBlock : public osmium::handler::Handler {
+
+            protected:
+
+                std::shared_ptr<osmium::memory::Buffer> m_input_buffer;
+
+                std::shared_ptr<std::string> m_out;
+
+                explicit OutputBlock(osmium::memory::Buffer&& buffer) :
+                    m_input_buffer(std::make_shared<osmium::memory::Buffer>(std::move(buffer))),
+                    m_out(std::make_shared<std::string>()) {
+                }
+
+                template <typename... TArgs>
+                void output_formatted(const char* format, TArgs&&... args) {
+                    append_printf_formatted_string(*m_out, format, std::forward<TArgs>(args)...);
+                }
+
+            }; // class OutputBlock;
+
+            /**
+             * Virtual base class for all classes writing OSM files in different
+             * formats.
+             *
+             * Do not use this class or derived classes directly. Use the
+             * osmium::io::Writer class instead.
+             */
+            class OutputFormat {
+
+            protected:
+
+                future_string_queue_type& m_output_queue;
+
+                /**
+                 * Wrap the string into a future and add it to the output
+                 * queue.
+                 */
+                void send_to_output_queue(std::string&& data) {
+                    add_to_queue(m_output_queue, std::move(data));
+                }
+
+            public:
+
+                explicit OutputFormat(future_string_queue_type& output_queue) :
+                    m_output_queue(output_queue) {
+                }
+
+                OutputFormat(const OutputFormat&) = delete;
+                OutputFormat(OutputFormat&&) = delete;
+
+                OutputFormat& operator=(const OutputFormat&) = delete;
+                OutputFormat& operator=(OutputFormat&&) = delete;
+
+                virtual ~OutputFormat() noexcept = default;
+
+                virtual void write_header(const osmium::io::Header&) {
+                }
+
+                virtual void write_buffer(osmium::memory::Buffer&&) = 0;
+
+                virtual void write_end() {
+                }
+
+            }; // class OutputFormat
+
+            /**
+             * This factory class is used to create objects that write OSM data
+             * into a specified output format.
+             *
+             * Do not use this class directly. Instead use the osmium::io::Writer
+             * class.
+             */
+            class OutputFormatFactory {
+
+            public:
+
+                typedef std::function<osmium::io::detail::OutputFormat*(const osmium::io::File&, future_string_queue_type&)> create_output_type;
+
+            private:
+
+                typedef std::map<osmium::io::file_format, create_output_type> map_type;
+
+                map_type m_callbacks;
+
+                OutputFormatFactory() :
+                    m_callbacks() {
+                }
+
+            public:
+
+                static OutputFormatFactory& instance() {
+                    static OutputFormatFactory factory;
+                    return factory;
+                }
+
+                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) {
+                        return false;
+                    }
+                    return true;
+                }
+
+                std::unique_ptr<osmium::io::detail::OutputFormat> create_output(const osmium::io::File& file, future_string_queue_type& output_queue) {
+                    auto it = m_callbacks.find(file.format());
+                    if (it != m_callbacks.end()) {
+                        return std::unique_ptr<osmium::io::detail::OutputFormat>((it->second)(file, output_queue));
+                    }
+
+                    throw unsupported_file_format_error(
+                                std::string("Can not open file '") +
+                                file.filename() +
+                                "' with type '" +
+                                as_string(file.format()) +
+                                "'. No support for writing this format in this program.");
+                }
+
+            }; // class OutputFormatFactory
+
+        } // namespace detail
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_DETAIL_OUTPUT_FORMAT_HPP

third_party/libosmium/include/osmium/io/detail/pbf.hpp

@@ -0,0 +1,89 @@
+#ifndef OSMIUM_IO_DETAIL_PBF_HPP
+#define OSMIUM_IO_DETAIL_PBF_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <cstdint>
+#include <string>
+
+// needed for htonl and ntohl
+#ifndef _WIN32
+# include <netinet/in.h>
+#else
+# include <winsock2.h>
+#endif
+
+#include <osmium/io/error.hpp>
+#include <osmium/osm/location.hpp>
+
+namespace osmium {
+
+    /**
+     * Exception thrown when there was a problem with parsing the PBF format of
+     * a file.
+     */
+    struct pbf_error : public io_error {
+
+        explicit pbf_error(const std::string& what) :
+            io_error(std::string("PBF error: ") + what) {
+        }
+
+        explicit pbf_error(const char* what) :
+            io_error(std::string("PBF error: ") + what) {
+        }
+
+    }; // struct pbf_error
+
+    namespace io {
+
+        namespace detail {
+
+            // the maximum size of a blob header in bytes
+            const int max_blob_header_size = 64 * 1024; // 64 kB
+
+            // the maximum size of an uncompressed blob in bytes
+            const uint64_t max_uncompressed_blob_size = 32 * 1024 * 1024; // 32 MB
+
+            // resolution for longitude/latitude used for conversion
+            // between representation as double and as int
+            const int64_t lonlat_resolution = 1000 * 1000 * 1000;
+
+            const int64_t resolution_convert = lonlat_resolution / osmium::Location::coordinate_precision;
+
+        } // namespace detail
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_DETAIL_PBF_HPP

third_party/libosmium/include/osmium/io/detail/pbf_decoder.hpp

@@ -0,0 +1,777 @@
+#ifndef OSMIUM_IO_DETAIL_PBF_DECODER_HPP
+#define OSMIUM_IO_DETAIL_PBF_DECODER_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <protozero/pbf_message.hpp>
+
+#include <osmium/builder/osm_object_builder.hpp>
+#include <osmium/io/detail/pbf.hpp> // IWYU pragma: export
+#include <osmium/io/detail/protobuf_tags.hpp>
+#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>
+#include <osmium/util/delta.hpp>
+
+namespace osmium {
+
+    namespace io {
+
+        namespace detail {
+
+            using ptr_len_type = std::pair<const char*, size_t>;
+            using osm_string_len_type = std::pair<const char*, osmium::string_size_type>;
+
+            class PBFPrimitiveBlockDecoder {
+
+                static constexpr size_t initial_buffer_size = 2 * 1024 * 1024;
+
+                ptr_len_type m_data;
+                std::vector<osm_string_len_type> m_stringtable;
+
+                int64_t m_lon_offset = 0;
+                int64_t m_lat_offset = 0;
+                int64_t m_date_factor = 1000;
+                int32_t m_granularity = 100;
+
+                osmium::osm_entity_bits::type m_read_types;
+
+                osmium::memory::Buffer m_buffer { initial_buffer_size };
+
+                void decode_stringtable(const ptr_len_type& data) {
+                    if (!m_stringtable.empty()) {
+                        throw osmium::pbf_error("more than one stringtable in pbf file");
+                    }
+
+                    protozero::pbf_message<OSMFormat::StringTable> pbf_string_table(data);
+                    while (pbf_string_table.next(OSMFormat::StringTable::repeated_bytes_s)) {
+                        auto str_len = pbf_string_table.get_data();
+                        if (str_len.second > osmium::max_osm_string_length) {
+                            throw osmium::pbf_error("overlong string in string table");
+                        }
+                        m_stringtable.emplace_back(str_len.first, osmium::string_size_type(str_len.second));
+                    }
+                }
+
+                void decode_primitive_block_metadata() {
+                    protozero::pbf_message<OSMFormat::PrimitiveBlock> pbf_primitive_block(m_data);
+                    while (pbf_primitive_block.next()) {
+                        switch (pbf_primitive_block.tag()) {
+                            case OSMFormat::PrimitiveBlock::required_StringTable_stringtable:
+                                decode_stringtable(pbf_primitive_block.get_data());
+                                break;
+                            case OSMFormat::PrimitiveBlock::optional_int32_granularity:
+                                m_granularity = pbf_primitive_block.get_int32();
+                                break;
+                            case OSMFormat::PrimitiveBlock::optional_int32_date_granularity:
+                                m_date_factor = pbf_primitive_block.get_int32();
+                                break;
+                            case OSMFormat::PrimitiveBlock::optional_int64_lat_offset:
+                                m_lat_offset = pbf_primitive_block.get_int64();
+                                break;
+                            case OSMFormat::PrimitiveBlock::optional_int64_lon_offset:
+                                m_lon_offset = pbf_primitive_block.get_int64();
+                                break;
+                            default:
+                                pbf_primitive_block.skip();
+                        }
+                    }
+                }
+
+                void decode_primitive_block_data() {
+                    protozero::pbf_message<OSMFormat::PrimitiveBlock> pbf_primitive_block(m_data);
+                    while (pbf_primitive_block.next(OSMFormat::PrimitiveBlock::repeated_PrimitiveGroup_primitivegroup)) {
+                        protozero::pbf_message<OSMFormat::PrimitiveGroup> pbf_primitive_group = pbf_primitive_block.get_message();
+                        while (pbf_primitive_group.next()) {
+                            switch (pbf_primitive_group.tag()) {
+                                case OSMFormat::PrimitiveGroup::repeated_Node_nodes:
+                                    if (m_read_types & osmium::osm_entity_bits::node) {
+                                        decode_node(pbf_primitive_group.get_data());
+                                    } else {
+                                        pbf_primitive_group.skip();
+                                    }
+                                    break;
+                                case OSMFormat::PrimitiveGroup::optional_DenseNodes_dense:
+                                    if (m_read_types & osmium::osm_entity_bits::node) {
+                                        decode_dense_nodes(pbf_primitive_group.get_data());
+                                    } else {
+                                        pbf_primitive_group.skip();
+                                    }
+                                    break;
+                                case OSMFormat::PrimitiveGroup::repeated_Way_ways:
+                                    if (m_read_types & osmium::osm_entity_bits::way) {
+                                        decode_way(pbf_primitive_group.get_data());
+                                    } else {
+                                        pbf_primitive_group.skip();
+                                    }
+                                    break;
+                                case OSMFormat::PrimitiveGroup::repeated_Relation_relations:
+                                    if (m_read_types & osmium::osm_entity_bits::relation) {
+                                        decode_relation(pbf_primitive_group.get_data());
+                                    } else {
+                                        pbf_primitive_group.skip();
+                                    }
+                                    break;
+                                default:
+                                    pbf_primitive_group.skip();
+                            }
+                        }
+                    }
+                }
+
+                osm_string_len_type decode_info(const ptr_len_type& data, osmium::OSMObject& object) {
+                    osm_string_len_type user = std::make_pair("", 0);
+
+                    protozero::pbf_message<OSMFormat::Info> pbf_info(data);
+                    while (pbf_info.next()) {
+                        switch (pbf_info.tag()) {
+                            case OSMFormat::Info::optional_int32_version:
+                                {
+                                    auto version = pbf_info.get_int32();
+                                    if (version < 0) {
+                                        throw osmium::pbf_error("object version must not be negative");
+                                    }
+                                    object.set_version(static_cast_with_assert<object_version_type>(version));
+                                }
+                                break;
+                            case OSMFormat::Info::optional_int64_timestamp:
+                                object.set_timestamp(pbf_info.get_int64() * m_date_factor / 1000);
+                                break;
+                            case OSMFormat::Info::optional_int64_changeset:
+                                {
+                                    auto changeset_id = pbf_info.get_int64();
+                                    if (changeset_id < 0) {
+                                        throw osmium::pbf_error("object changeset_id must not be negative");
+                                    }
+                                    object.set_changeset(static_cast_with_assert<changeset_id_type>(changeset_id));
+                                }
+                                break;
+                            case OSMFormat::Info::optional_int32_uid:
+                                object.set_uid_from_signed(pbf_info.get_int32());
+                                break;
+                            case OSMFormat::Info::optional_uint32_user_sid:
+                                user = m_stringtable.at(pbf_info.get_uint32());
+                                break;
+                            case OSMFormat::Info::optional_bool_visible:
+                                object.set_visible(pbf_info.get_bool());
+                                break;
+                            default:
+                                pbf_info.skip();
+                        }
+                    }
+
+                    return user;
+                }
+
+                using kv_type = std::pair<protozero::pbf_reader::const_uint32_iterator, protozero::pbf_reader::const_uint32_iterator>;
+
+                void build_tag_list(osmium::builder::Builder& builder, const kv_type& keys, const kv_type& vals) {
+                    if (keys.first != keys.second) {
+                        osmium::builder::TagListBuilder tl_builder(m_buffer, &builder);
+                        auto kit = keys.first;
+                        auto vit = vals.first;
+                        while (kit != keys.second) {
+                            if (vit == vals.second) {
+                                // this is against the spec, must have same number of elements
+                                throw osmium::pbf_error("PBF format error");
+                            }
+                            const auto& k = m_stringtable.at(*kit++);
+                            const auto& v = m_stringtable.at(*vit++);
+                            tl_builder.add_tag(k.first, k.second, v.first, v.second);
+                        }
+                    }
+                }
+
+                int32_t convert_pbf_coordinate(int64_t c) const {
+                    return int32_t((c * m_granularity + m_lon_offset) / resolution_convert);
+                }
+
+                void decode_node(const ptr_len_type& data) {
+                    osmium::builder::NodeBuilder builder(m_buffer);
+                    osmium::Node& node = builder.object();
+
+                    kv_type keys;
+                    kv_type vals;
+                    int64_t lon = std::numeric_limits<int64_t>::max();
+                    int64_t lat = std::numeric_limits<int64_t>::max();
+
+                    osm_string_len_type user = { "", 0 };
+
+                    protozero::pbf_message<OSMFormat::Node> pbf_node(data);
+                    while (pbf_node.next()) {
+                        switch (pbf_node.tag()) {
+                            case OSMFormat::Node::required_sint64_id:
+                                node.set_id(pbf_node.get_sint64());
+                                break;
+                            case OSMFormat::Node::packed_uint32_keys:
+                                keys = pbf_node.get_packed_uint32();
+                                break;
+                            case OSMFormat::Node::packed_uint32_vals:
+                                vals = pbf_node.get_packed_uint32();
+                                break;
+                            case OSMFormat::Node::optional_Info_info:
+                                user = decode_info(pbf_node.get_data(), builder.object());
+                                break;
+                            case OSMFormat::Node::required_sint64_lat:
+                                lat = pbf_node.get_sint64();
+                                break;
+                            case OSMFormat::Node::required_sint64_lon:
+                                lon = pbf_node.get_sint64();
+                                break;
+                            default:
+                                pbf_node.skip();
+                        }
+                    }
+
+                    if (node.visible()) {
+                        if (lon == std::numeric_limits<int64_t>::max() ||
+                            lat == std::numeric_limits<int64_t>::max()) {
+                            throw osmium::pbf_error("illegal coordinate format");
+                        }
+                        node.set_location(osmium::Location(
+                                convert_pbf_coordinate(lon),
+                                convert_pbf_coordinate(lat)
+                        ));
+                    }
+
+                    builder.add_user(user.first, user.second);
+
+                    build_tag_list(builder, keys, vals);
+
+                    m_buffer.commit();
+                }
+
+                void decode_way(const ptr_len_type& data) {
+                    osmium::builder::WayBuilder builder(m_buffer);
+
+                    kv_type keys;
+                    kv_type vals;
+                    std::pair<protozero::pbf_reader::const_sint64_iterator, protozero::pbf_reader::const_sint64_iterator> refs;
+
+                    osm_string_len_type user = { "", 0 };
+
+                    protozero::pbf_message<OSMFormat::Way> pbf_way(data);
+                    while (pbf_way.next()) {
+                        switch (pbf_way.tag()) {
+                            case OSMFormat::Way::required_int64_id:
+                                builder.object().set_id(pbf_way.get_int64());
+                                break;
+                            case OSMFormat::Way::packed_uint32_keys:
+                                keys = pbf_way.get_packed_uint32();
+                                break;
+                            case OSMFormat::Way::packed_uint32_vals:
+                                vals = pbf_way.get_packed_uint32();
+                                break;
+                            case OSMFormat::Way::optional_Info_info:
+                                user = decode_info(pbf_way.get_data(), builder.object());
+                                break;
+                            case OSMFormat::Way::packed_sint64_refs:
+                                refs = pbf_way.get_packed_sint64();
+                                break;
+                            default:
+                                pbf_way.skip();
+                        }
+                    }
+
+                    builder.add_user(user.first, user.second);
+
+                    if (refs.first != refs.second) {
+                        osmium::builder::WayNodeListBuilder wnl_builder(m_buffer, &builder);
+                        osmium::util::DeltaDecode<int64_t> ref;
+                        while (refs.first != refs.second) {
+                            wnl_builder.add_node_ref(ref.update(*refs.first++));
+                        }
+                    }
+
+                    build_tag_list(builder, keys, vals);
+
+                    m_buffer.commit();
+                }
+
+                void decode_relation(const ptr_len_type& data) {
+                    osmium::builder::RelationBuilder builder(m_buffer);
+
+                    kv_type keys;
+                    kv_type vals;
+                    std::pair<protozero::pbf_reader::const_int32_iterator,  protozero::pbf_reader::const_int32_iterator> roles;
+                    std::pair<protozero::pbf_reader::const_sint64_iterator, protozero::pbf_reader::const_sint64_iterator> refs;
+                    std::pair<protozero::pbf_reader::const_int32_iterator,  protozero::pbf_reader::const_int32_iterator> types;
+
+                    osm_string_len_type user = { "", 0 };
+
+                    protozero::pbf_message<OSMFormat::Relation> pbf_relation(data);
+                    while (pbf_relation.next()) {
+                        switch (pbf_relation.tag()) {
+                            case OSMFormat::Relation::required_int64_id:
+                                builder.object().set_id(pbf_relation.get_int64());
+                                break;
+                            case OSMFormat::Relation::packed_uint32_keys:
+                                keys = pbf_relation.get_packed_uint32();
+                                break;
+                            case OSMFormat::Relation::packed_uint32_vals:
+                                vals = pbf_relation.get_packed_uint32();
+                                break;
+                            case OSMFormat::Relation::optional_Info_info:
+                                user = decode_info(pbf_relation.get_data(), builder.object());
+                                break;
+                            case OSMFormat::Relation::packed_int32_roles_sid:
+                                roles = pbf_relation.get_packed_int32();
+                                break;
+                            case OSMFormat::Relation::packed_sint64_memids:
+                                refs = pbf_relation.get_packed_sint64();
+                                break;
+                            case OSMFormat::Relation::packed_MemberType_types:
+                                types = pbf_relation.get_packed_enum();
+                                break;
+                            default:
+                                pbf_relation.skip();
+                        }
+                    }
+
+                    builder.add_user(user.first, user.second);
+
+                    if (refs.first != refs.second) {
+                        osmium::builder::RelationMemberListBuilder rml_builder(m_buffer, &builder);
+                        osmium::util::DeltaDecode<int64_t> ref;
+                        while (roles.first != roles.second && refs.first != refs.second && types.first != types.second) {
+                            const auto& r = m_stringtable.at(*roles.first++);
+                            int type = *types.first++;
+                            if (type < 0 || type > 2) {
+                                throw osmium::pbf_error("unknown relation member type");
+                            }
+                            rml_builder.add_member(
+                                osmium::item_type(type + 1),
+                                ref.update(*refs.first++),
+                                r.first,
+                                r.second
+                            );
+                        }
+                    }
+
+                    build_tag_list(builder, keys, vals);
+
+                    m_buffer.commit();
+                }
+
+                void decode_dense_nodes(const ptr_len_type& data) {
+                    bool has_info     = false;
+                    bool has_visibles = false;
+
+                    std::pair<protozero::pbf_reader::const_sint64_iterator, protozero::pbf_reader::const_sint64_iterator> ids;
+                    std::pair<protozero::pbf_reader::const_sint64_iterator, protozero::pbf_reader::const_sint64_iterator> lats;
+                    std::pair<protozero::pbf_reader::const_sint64_iterator, protozero::pbf_reader::const_sint64_iterator> lons;
+
+                    std::pair<protozero::pbf_reader::const_int32_iterator,  protozero::pbf_reader::const_int32_iterator>  tags;
+
+                    std::pair<protozero::pbf_reader::const_int32_iterator,  protozero::pbf_reader::const_int32_iterator>  versions;
+                    std::pair<protozero::pbf_reader::const_sint64_iterator, protozero::pbf_reader::const_sint64_iterator> timestamps;
+                    std::pair<protozero::pbf_reader::const_sint64_iterator, protozero::pbf_reader::const_sint64_iterator> changesets;
+                    std::pair<protozero::pbf_reader::const_sint32_iterator, protozero::pbf_reader::const_sint32_iterator> uids;
+                    std::pair<protozero::pbf_reader::const_sint32_iterator, protozero::pbf_reader::const_sint32_iterator> user_sids;
+                    std::pair<protozero::pbf_reader::const_int32_iterator,  protozero::pbf_reader::const_int32_iterator>  visibles;
+
+                    protozero::pbf_message<OSMFormat::DenseNodes> pbf_dense_nodes(data);
+                    while (pbf_dense_nodes.next()) {
+                        switch (pbf_dense_nodes.tag()) {
+                            case OSMFormat::DenseNodes::packed_sint64_id:
+                                ids = pbf_dense_nodes.get_packed_sint64();
+                                break;
+                            case OSMFormat::DenseNodes::optional_DenseInfo_denseinfo:
+                                {
+                                    has_info = true;
+                                    protozero::pbf_message<OSMFormat::DenseInfo> pbf_dense_info = pbf_dense_nodes.get_message();
+                                    while (pbf_dense_info.next()) {
+                                        switch (pbf_dense_info.tag()) {
+                                            case OSMFormat::DenseInfo::packed_int32_version:
+                                                versions = pbf_dense_info.get_packed_int32();
+                                                break;
+                                            case OSMFormat::DenseInfo::packed_sint64_timestamp:
+                                                timestamps = pbf_dense_info.get_packed_sint64();
+                                                break;
+                                            case OSMFormat::DenseInfo::packed_sint64_changeset:
+                                                changesets = pbf_dense_info.get_packed_sint64();
+                                                break;
+                                            case OSMFormat::DenseInfo::packed_sint32_uid:
+                                                uids = pbf_dense_info.get_packed_sint32();
+                                                break;
+                                            case OSMFormat::DenseInfo::packed_sint32_user_sid:
+                                                user_sids = pbf_dense_info.get_packed_sint32();
+                                                break;
+                                            case OSMFormat::DenseInfo::packed_bool_visible:
+                                                has_visibles = true;
+                                                visibles = pbf_dense_info.get_packed_bool();
+                                                break;
+                                            default:
+                                                pbf_dense_info.skip();
+                                        }
+                                    }
+                                }
+                                break;
+                            case OSMFormat::DenseNodes::packed_sint64_lat:
+                                lats = pbf_dense_nodes.get_packed_sint64();
+                                break;
+                            case OSMFormat::DenseNodes::packed_sint64_lon:
+                                lons = pbf_dense_nodes.get_packed_sint64();
+                                break;
+                            case OSMFormat::DenseNodes::packed_int32_keys_vals:
+                                tags = pbf_dense_nodes.get_packed_int32();
+                                break;
+                            default:
+                                pbf_dense_nodes.skip();
+                        }
+                    }
+
+                    osmium::util::DeltaDecode<int64_t> dense_id;
+                    osmium::util::DeltaDecode<int64_t> dense_latitude;
+                    osmium::util::DeltaDecode<int64_t> dense_longitude;
+                    osmium::util::DeltaDecode<int64_t> dense_uid;
+                    osmium::util::DeltaDecode<int64_t> dense_user_sid;
+                    osmium::util::DeltaDecode<int64_t> dense_changeset;
+                    osmium::util::DeltaDecode<int64_t> dense_timestamp;
+
+                    auto tag_it = tags.first;
+
+                    while (ids.first != ids.second) {
+                        if (lons.first == lons.second ||
+                            lats.first == lats.second) {
+                            // this is against the spec, must have same number of elements
+                            throw osmium::pbf_error("PBF format error");
+                        }
+
+                        bool visible = true;
+
+                        osmium::builder::NodeBuilder builder(m_buffer);
+                        osmium::Node& node = builder.object();
+
+                        node.set_id(dense_id.update(*ids.first++));
+
+                        if (has_info) {
+                            if (versions.first == versions.second ||
+                                changesets.first == changesets.second ||
+                                timestamps.first == timestamps.second ||
+                                uids.first == uids.second ||
+                                user_sids.first == user_sids.second) {
+                                // this is against the spec, must have same number of elements
+                                throw osmium::pbf_error("PBF format error");
+                            }
+
+                            auto version = *versions.first++;
+                            if (version < 0) {
+                                throw osmium::pbf_error("object version must not be negative");
+                            }
+                            node.set_version(static_cast<osmium::object_version_type>(version));
+
+                            auto changeset_id = dense_changeset.update(*changesets.first++);
+                            if (changeset_id < 0) {
+                                throw osmium::pbf_error("object changeset_id must not be negative");
+                            }
+                            node.set_changeset(static_cast<osmium::changeset_id_type>(changeset_id));
+
+                            node.set_timestamp(dense_timestamp.update(*timestamps.first++) * m_date_factor / 1000);
+                            node.set_uid_from_signed(static_cast<osmium::signed_user_id_type>(dense_uid.update(*uids.first++)));
+
+                            if (has_visibles) {
+                                if (visibles.first == visibles.second) {
+                                    // this is against the spec, must have same number of elements
+                                    throw osmium::pbf_error("PBF format error");
+                                }
+                                visible = (*visibles.first++) != 0;
+                            }
+                            node.set_visible(visible);
+
+                            const auto& u = m_stringtable.at(dense_user_sid.update(*user_sids.first++));
+                            builder.add_user(u.first, u.second);
+                        } else {
+                            builder.add_user("");
+                        }
+
+                        // even if the node isn't visible, there's still a record
+                        // of its lat/lon in the dense arrays.
+                        const auto lon = dense_longitude.update(*lons.first++);
+                        const auto lat = dense_latitude.update(*lats.first++);
+                        if (visible) {
+                            builder.object().set_location(osmium::Location(
+                                    convert_pbf_coordinate(lon),
+                                    convert_pbf_coordinate(lat)
+                            ));
+                        }
+
+                        if (tag_it != tags.second) {
+                            osmium::builder::TagListBuilder tl_builder(m_buffer, &builder);
+                            while (tag_it != tags.second && *tag_it != 0) {
+                                const auto& k = m_stringtable.at(*tag_it++);
+                                if (tag_it == tags.second) {
+                                    throw osmium::pbf_error("PBF format error"); // this is against the spec, keys/vals must come in pairs
+                                }
+                                const auto& v = m_stringtable.at(*tag_it++);
+                                tl_builder.add_tag(k.first, k.second, v.first, v.second);
+                            }
+
+                            if (tag_it != tags.second) {
+                                ++tag_it;
+                            }
+                        }
+
+                        m_buffer.commit();
+                    }
+
+                }
+
+            public:
+
+                PBFPrimitiveBlockDecoder(const ptr_len_type& data, osmium::osm_entity_bits::type read_types) :
+                    m_data(data),
+                    m_read_types(read_types) {
+                }
+
+                PBFPrimitiveBlockDecoder(const PBFPrimitiveBlockDecoder&) = delete;
+                PBFPrimitiveBlockDecoder& operator=(const PBFPrimitiveBlockDecoder&) = delete;
+
+                PBFPrimitiveBlockDecoder(PBFPrimitiveBlockDecoder&&) = delete;
+                PBFPrimitiveBlockDecoder& operator=(PBFPrimitiveBlockDecoder&&) = delete;
+
+                ~PBFPrimitiveBlockDecoder() noexcept = default;
+
+                osmium::memory::Buffer operator()() {
+                    try {
+                        decode_primitive_block_metadata();
+                        decode_primitive_block_data();
+                    } catch (std::out_of_range&) {
+                        throw osmium::pbf_error("string id out of range");
+                    }
+
+                    return std::move(m_buffer);
+                }
+
+            }; // class PBFPrimitiveBlockDecoder
+
+            inline ptr_len_type decode_blob(const std::string& blob_data, std::string& output) {
+                int32_t raw_size = 0;
+                std::pair<const char*, protozero::pbf_length_type> zlib_data = {nullptr, 0};
+
+                protozero::pbf_message<FileFormat::Blob> pbf_blob(blob_data);
+                while (pbf_blob.next()) {
+                    switch (pbf_blob.tag()) {
+                        case FileFormat::Blob::optional_bytes_raw:
+                            {
+                                auto data_len = pbf_blob.get_data();
+                                if (data_len.second > max_uncompressed_blob_size) {
+                                    throw osmium::pbf_error("illegal blob size");
+                                }
+                                return data_len;
+                            }
+                        case FileFormat::Blob::optional_int32_raw_size:
+                            raw_size = pbf_blob.get_int32();
+                            if (raw_size <= 0 || uint32_t(raw_size) > max_uncompressed_blob_size) {
+                                throw osmium::pbf_error("illegal blob size");
+                            }
+                            break;
+                        case FileFormat::Blob::optional_bytes_zlib_data:
+                            zlib_data = pbf_blob.get_data();
+                            break;
+                        case FileFormat::Blob::optional_bytes_lzma_data:
+                            throw osmium::pbf_error("lzma blobs not implemented");
+                        default:
+                            throw osmium::pbf_error("unknown compression");
+                    }
+                }
+
+                if (zlib_data.second != 0 && raw_size != 0) {
+                    return osmium::io::detail::zlib_uncompress_string(
+                        zlib_data.first,
+                        static_cast<unsigned long>(zlib_data.second),
+                        static_cast<unsigned long>(raw_size),
+                        output
+                    );
+                }
+
+                throw osmium::pbf_error("blob contains no data");
+            }
+
+            inline osmium::Box decode_header_bbox(const ptr_len_type& data) {
+                    int64_t left   = std::numeric_limits<int64_t>::max();
+                    int64_t right  = std::numeric_limits<int64_t>::max();
+                    int64_t top    = std::numeric_limits<int64_t>::max();
+                    int64_t bottom = std::numeric_limits<int64_t>::max();
+
+                    protozero::pbf_message<OSMFormat::HeaderBBox> pbf_header_bbox(data);
+                    while (pbf_header_bbox.next()) {
+                        switch (pbf_header_bbox.tag()) {
+                            case OSMFormat::HeaderBBox::required_sint64_left:
+                                left = pbf_header_bbox.get_sint64();
+                                break;
+                            case OSMFormat::HeaderBBox::required_sint64_right:
+                                right = pbf_header_bbox.get_sint64();
+                                break;
+                            case OSMFormat::HeaderBBox::required_sint64_top:
+                                top = pbf_header_bbox.get_sint64();
+                                break;
+                            case OSMFormat::HeaderBBox::required_sint64_bottom:
+                                bottom = pbf_header_bbox.get_sint64();
+                                break;
+                            default:
+                                pbf_header_bbox.skip();
+                        }
+                    }
+
+                    if (left   == std::numeric_limits<int64_t>::max() ||
+                        right  == std::numeric_limits<int64_t>::max() ||
+                        top    == std::numeric_limits<int64_t>::max() ||
+                        bottom == std::numeric_limits<int64_t>::max()) {
+                        throw osmium::pbf_error("invalid bbox");
+                    }
+
+                    osmium::Box box;
+                    box.extend(osmium::Location(left  / resolution_convert, bottom / resolution_convert));
+                    box.extend(osmium::Location(right / resolution_convert, top    / resolution_convert));
+
+                    return box;
+            }
+
+            inline osmium::io::Header decode_header_block(const ptr_len_type& data) {
+                osmium::io::Header header;
+                int i = 0;
+
+                protozero::pbf_message<OSMFormat::HeaderBlock> pbf_header_block(data);
+                while (pbf_header_block.next()) {
+                    switch (pbf_header_block.tag()) {
+                        case OSMFormat::HeaderBlock::optional_HeaderBBox_bbox:
+                            header.add_box(decode_header_bbox(pbf_header_block.get_data()));
+                            break;
+                        case OSMFormat::HeaderBlock::repeated_string_required_features:
+                            {
+                                auto feature = pbf_header_block.get_data();
+                                if (!strncmp("OsmSchema-V0.6", feature.first, feature.second)) {
+                                    // intentionally left blank
+                                } else if (!strncmp("DenseNodes", feature.first, feature.second)) {
+                                    header.set("pbf_dense_nodes", true);
+                                } else if (!strncmp("HistoricalInformation", feature.first, feature.second)) {
+                                    header.set_has_multiple_object_versions(true);
+                                } else {
+                                    std::string msg("required feature not supported: ");
+                                    msg.append(feature.first, feature.second);
+                                    throw osmium::pbf_error(msg);
+                                }
+                            }
+                            break;
+                        case OSMFormat::HeaderBlock::repeated_string_optional_features:
+                            header.set("pbf_optional_feature_" + std::to_string(i++), pbf_header_block.get_string());
+                            break;
+                        case OSMFormat::HeaderBlock::optional_string_writingprogram:
+                            header.set("generator", pbf_header_block.get_string());
+                            break;
+                        case OSMFormat::HeaderBlock::optional_int64_osmosis_replication_timestamp:
+                            {
+                                auto timestamp = osmium::Timestamp(pbf_header_block.get_int64()).to_iso();
+                                header.set("osmosis_replication_timestamp", timestamp);
+                                header.set("timestamp", timestamp);
+                            }
+                            break;
+                        case OSMFormat::HeaderBlock::optional_int64_osmosis_replication_sequence_number:
+                            header.set("osmosis_replication_sequence_number", std::to_string(pbf_header_block.get_int64()));
+                            break;
+                        case OSMFormat::HeaderBlock::optional_string_osmosis_replication_base_url:
+                            header.set("osmosis_replication_base_url", pbf_header_block.get_string());
+                            break;
+                        default:
+                            pbf_header_block.skip();
+                    }
+                }
+
+                return header;
+            }
+
+            /**
+             * Decode HeaderBlock.
+             *
+             * @param header_block_data Input data
+             * @returns Header object
+             * @throws osmium::pbf_error If there was a parsing error
+             */
+            inline osmium::io::Header decode_header(const std::string& header_block_data) {
+                std::string output;
+
+                return decode_header_block(decode_blob(header_block_data, output));
+            }
+
+            class PBFDataBlobDecoder {
+
+                std::shared_ptr<std::string> m_input_buffer;
+                osmium::osm_entity_bits::type m_read_types;
+
+            public:
+
+                PBFDataBlobDecoder(std::string&& input_buffer, osmium::osm_entity_bits::type read_types) :
+                    m_input_buffer(std::make_shared<std::string>(std::move(input_buffer))),
+                    m_read_types(read_types) {
+                }
+
+                PBFDataBlobDecoder(const PBFDataBlobDecoder&) = default;
+                PBFDataBlobDecoder& operator=(const PBFDataBlobDecoder&) = default;
+
+                PBFDataBlobDecoder(PBFDataBlobDecoder&&) = default;
+                PBFDataBlobDecoder& operator=(PBFDataBlobDecoder&&) = default;
+
+                ~PBFDataBlobDecoder() noexcept = default;
+
+                osmium::memory::Buffer operator()() {
+                    std::string output;
+                    PBFPrimitiveBlockDecoder decoder(decode_blob(*m_input_buffer, output), m_read_types);
+                    return decoder();
+                }
+
+            }; // class PBFDataBlobDecoder
+
+        } // namespace detail
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_DETAIL_PBF_DECODER_HPP

third_party/libosmium/include/osmium/io/detail/pbf_input_format.hpp

@@ -0,0 +1,242 @@
+#ifndef OSMIUM_IO_DETAIL_PBF_INPUT_FORMAT_HPP
+#define OSMIUM_IO_DETAIL_PBF_INPUT_FORMAT_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <thread>
+#include <type_traits>
+
+#include <protozero/pbf_message.hpp>
+
+#include <osmium/io/detail/input_format.hpp>
+#include <osmium/io/detail/pbf.hpp> // IWYU pragma: export
+#include <osmium/io/detail/pbf_decoder.hpp>
+#include <osmium/io/detail/protobuf_tags.hpp>
+#include <osmium/io/error.hpp>
+#include <osmium/io/file.hpp>
+#include <osmium/io/file_format.hpp>
+#include <osmium/osm.hpp>
+#include <osmium/osm/entity_bits.hpp>
+#include <osmium/osm/object.hpp>
+#include <osmium/osm/timestamp.hpp>
+#include <osmium/thread/pool.hpp>
+#include <osmium/thread/util.hpp>
+#include <osmium/util/config.hpp>
+
+namespace osmium {
+
+    namespace io {
+
+        namespace detail {
+
+            class PBFParser : public Parser {
+
+                std::string m_input_buffer;
+
+                /**
+                 * Read the given number of bytes from the input queue.
+                 *
+                 * @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 = get_input();
+                        if (input_done()) {
+                            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);
+
+                    using std::swap;
+                    swap(output, m_input_buffer);
+
+                    return output;
+                }
+
+                /**
+                 * Read 4 bytes in network byte order from file. They contain
+                 * the length of the following BlobHeader.
+                 */
+                uint32_t read_blob_header_size_from_file() {
+                    uint32_t size_in_network_byte_order;
+
+                    try {
+                        const 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
+                    }
+
+                    const uint32_t size = ntohl(size_in_network_byte_order);
+                    if (size > static_cast<uint32_t>(max_blob_header_size)) {
+                        throw osmium::pbf_error("invalid BlobHeader size (> max_blob_header_size)");
+                    }
+
+                    return size;
+                }
+
+                /**
+                 * Decode the BlobHeader. Make sure it contains the expected
+                 * type. Return the size of the following Blob.
+                 */
+                size_t decode_blob_header(protozero::pbf_message<FileFormat::BlobHeader>&& pbf_blob_header, const char* expected_type) {
+                    std::pair<const char*, size_t> blob_header_type;
+                    size_t blob_header_datasize = 0;
+
+                    while (pbf_blob_header.next()) {
+                        switch (pbf_blob_header.tag()) {
+                            case FileFormat::BlobHeader::required_string_type:
+                                blob_header_type = pbf_blob_header.get_data();
+                                break;
+                            case FileFormat::BlobHeader::required_int32_datasize:
+                                blob_header_datasize = pbf_blob_header.get_int32();
+                                break;
+                            default:
+                                pbf_blob_header.skip();
+                        }
+                    }
+
+                    if (blob_header_datasize == 0) {
+                        throw osmium::pbf_error("PBF format error: BlobHeader.datasize missing or zero.");
+                    }
+
+                    if (strncmp(expected_type, blob_header_type.first, blob_header_type.second)) {
+                        throw osmium::pbf_error("blob does not have expected type (OSMHeader in first blob, OSMData in following blobs)");
+                    }
+
+                    return blob_header_datasize;
+                }
+
+                size_t check_type_and_get_blob_size(const char* expected_type) {
+                    assert(expected_type);
+
+                    const auto size = read_blob_header_size_from_file();
+                    if (size == 0) { // EOF
+                        return 0;
+                    }
+
+                    const std::string blob_header = read_from_input_queue(size);
+
+                    return decode_blob_header(protozero::pbf_message<FileFormat::BlobHeader>(blob_header), expected_type);
+                }
+
+                std::string read_from_input_queue_with_check(size_t size) {
+                    if (size > max_uncompressed_blob_size) {
+                        throw osmium::pbf_error(std::string("invalid blob size: " +
+                                                std::to_string(size)));
+                    }
+                    return read_from_input_queue(size);
+                }
+
+                // Parse the header in the PBF OSMHeader blob.
+                void parse_header_blob() {
+                    osmium::io::Header header;
+                    const auto size = check_type_and_get_blob_size("OSMHeader");
+                    header = decode_header(read_from_input_queue_with_check(size));
+                    set_header_value(header);
+                }
+
+                void parse_data_blobs() {
+                    while (const auto size = check_type_and_get_blob_size("OSMData")) {
+                        std::string input_buffer = read_from_input_queue_with_check(size);
+
+                        PBFDataBlobDecoder data_blob_parser{ std::move(input_buffer), read_types() };
+
+                        if (osmium::config::use_pool_threads_for_pbf_parsing()) {
+                            send_to_output_queue(osmium::thread::Pool::instance().submit(std::move(data_blob_parser)));
+                        } else {
+                            send_to_output_queue(data_blob_parser());
+                        }
+                    }
+                }
+
+            public:
+
+                PBFParser(future_string_queue_type& input_queue,
+                          future_buffer_queue_type& output_queue,
+                          std::promise<osmium::io::Header>& header_promise,
+                          osmium::osm_entity_bits::type read_types) :
+                    Parser(input_queue, output_queue, header_promise, read_types),
+                    m_input_buffer() {
+                }
+
+                ~PBFParser() noexcept final = default;
+
+                void run() final {
+                    osmium::thread::set_thread_name("_osmium_pbf_in");
+
+                    parse_header_blob();
+
+                    if (read_types() != osmium::osm_entity_bits::nothing) {
+                        parse_data_blobs();
+                    }
+                }
+
+            }; // class PBFParser
+
+            // we want the register_parser() function to run, setting
+            // the variable is only a side-effect, it will never be used
+            const bool registered_pbf_parser = ParserFactory::instance().register_parser(
+                file_format::pbf,
+                [](future_string_queue_type& input_queue,
+                    future_buffer_queue_type& output_queue,
+                    std::promise<osmium::io::Header>& header_promise,
+                    osmium::osm_entity_bits::type read_which_entities) {
+                    return std::unique_ptr<Parser>(new PBFParser(input_queue, output_queue, header_promise, read_which_entities));
+            });
+
+            // dummy function to silence the unused variable warning from above
+            inline bool get_registered_pbf_parser() noexcept {
+                return registered_pbf_parser;
+            }
+
+        } // namespace detail
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_DETAIL_PBF_INPUT_FORMAT_HPP

third_party/libosmium/include/osmium/io/detail/pbf_output_format.hpp

@@ -0,0 +1,636 @@
+#ifndef OSMIUM_IO_DETAIL_PBF_OUTPUT_FORMAT_HPP
+#define OSMIUM_IO_DETAIL_PBF_OUTPUT_FORMAT_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <algorithm>
+#include <cassert>
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+#include <iterator>
+#include <memory>
+#include <string>
+#include <time.h>
+#include <utility>
+
+#include <protozero/pbf_builder.hpp>
+
+#include <osmium/handler.hpp>
+#include <osmium/io/detail/output_format.hpp>
+#include <osmium/io/detail/pbf.hpp> // IWYU pragma: export
+#include <osmium/io/detail/protobuf_tags.hpp>
+#include <osmium/io/detail/string_table.hpp>
+#include <osmium/io/detail/zlib.hpp>
+#include <osmium/io/file.hpp>
+#include <osmium/io/file_format.hpp>
+#include <osmium/io/header.hpp>
+#include <osmium/memory/buffer.hpp>
+#include <osmium/memory/collection.hpp>
+#include <osmium/osm/box.hpp>
+#include <osmium/osm/item_type.hpp>
+#include <osmium/osm/location.hpp>
+#include <osmium/osm/node.hpp>
+#include <osmium/osm/object.hpp>
+#include <osmium/osm/relation.hpp>
+#include <osmium/osm/tag.hpp>
+#include <osmium/osm/timestamp.hpp>
+#include <osmium/osm/way.hpp>
+#include <osmium/thread/pool.hpp>
+#include <osmium/util/cast.hpp>
+#include <osmium/util/delta.hpp>
+#include <osmium/visitor.hpp>
+
+namespace osmium {
+
+    namespace io {
+
+        namespace detail {
+
+            struct pbf_output_options {
+
+                /// Should nodes be encoded in DenseNodes?
+                bool use_dense_nodes;
+
+                /**
+                 * Should the PBF blobs contain zlib compressed data?
+                 *
+                 * The zlib compression is optional, it's possible to store the
+                 * blobs in raw format. Disabling the compression can improve
+                 * the writing speed a little but the output will be 2x to 3x
+                 * bigger.
+                 */
+                bool use_compression;
+
+                /// Should metadata of objects be written?
+                bool add_metadata;
+
+                /// Add the "HistoricalInformation" header flag.
+                bool add_historical_information_flag;
+
+                /// Should the visible flag be added to all OSM objects?
+                bool add_visible_flag;
+
+            };
+
+            /**
+             * Maximum number of items in a primitive block.
+             *
+             * The uncompressed length of a Blob *should* be less
+             * than 16 megabytes and *must* be less than 32 megabytes.
+             *
+             * A block may contain any number of entities, as long as
+             * the size limits for the surrounding blob are obeyed.
+             * However, for simplicity, the current Osmosis (0.38)
+             * as well as Osmium implementation always
+             * uses at most 8k entities in a block.
+             */
+            constexpr int32_t max_entities_per_block = 8000;
+
+            constexpr int location_granularity = 100;
+
+            /**
+             * convert a double lat or lon value to an int, respecting the granularity
+             */
+            inline int64_t lonlat2int(double lonlat) {
+                return static_cast<int64_t>(std::round(lonlat * lonlat_resolution / location_granularity));
+            }
+
+            enum class pbf_blob_type {
+                header = 0,
+                data = 1
+            };
+
+            class SerializeBlob {
+
+                std::string m_msg;
+
+                pbf_blob_type m_blob_type;
+
+                bool m_use_compression;
+
+            public:
+
+                /**
+                 * Initialize a blob serializer.
+                 *
+                 * @param msg Protobuf-message containing the blob data
+                 * @param type Type of blob.
+                 * @param use_compression Should the output be compressed using
+                 *        zlib?
+                 */
+                SerializeBlob(std::string&& msg, pbf_blob_type type, bool use_compression) :
+                    m_msg(std::move(msg)),
+                    m_blob_type(type),
+                    m_use_compression(use_compression) {
+                }
+
+                /**
+                 * Serialize a protobuf message into a Blob, optionally apply
+                 * compression and return it together with a BlobHeader ready
+                 * to be written to a file.
+                 */
+                std::string operator()() {
+                    assert(m_msg.size() <= max_uncompressed_blob_size);
+
+                    std::string blob_data;
+                    protozero::pbf_builder<FileFormat::Blob> pbf_blob(blob_data);
+
+                    if (m_use_compression) {
+                        pbf_blob.add_int32(FileFormat::Blob::optional_int32_raw_size, int32_t(m_msg.size()));
+                        pbf_blob.add_bytes(FileFormat::Blob::optional_bytes_zlib_data, osmium::io::detail::zlib_compress(m_msg));
+                    } else {
+                        pbf_blob.add_bytes(FileFormat::Blob::optional_bytes_raw, m_msg);
+                    }
+
+                    std::string blob_header_data;
+                    protozero::pbf_builder<FileFormat::BlobHeader> pbf_blob_header(blob_header_data);
+
+                    pbf_blob_header.add_string(FileFormat::BlobHeader::required_string_type, m_blob_type == pbf_blob_type::data ? "OSMData" : "OSMHeader");
+                    pbf_blob_header.add_int32(FileFormat::BlobHeader::required_int32_datasize, static_cast_with_assert<int32_t>(blob_data.size()));
+
+                    uint32_t sz = htonl(static_cast_with_assert<uint32_t>(blob_header_data.size()));
+
+                    // write to output: the 4-byte BlobHeader-Size followed by the BlobHeader followed by the Blob
+                    std::string output;
+                    output.reserve(sizeof(sz) + blob_header_data.size() + blob_data.size());
+                    output.append(reinterpret_cast<const char*>(&sz), sizeof(sz));
+                    output.append(blob_header_data);
+                    output.append(blob_data);
+
+                    return output;
+                }
+
+            }; // class SerializeBlob
+
+            /**
+             * Contains the code to pack any number of nodes into a DenseNode
+             * structure.
+             *
+             * Because this needs to allocate a lot of memory on the heap,
+             * only one object of this class will be created and then re-used
+             * after calling clear() on it.
+             */
+            class DenseNodes {
+
+                StringTable& m_stringtable;
+
+                std::vector<int64_t> m_ids;
+
+                std::vector<int32_t> m_versions;
+                std::vector<int64_t> m_timestamps;
+                std::vector<int64_t> m_changesets;
+                std::vector<int32_t> m_uids;
+                std::vector<int32_t> m_user_sids;
+                std::vector<bool> m_visibles;
+
+                std::vector<int64_t> m_lats;
+                std::vector<int64_t> m_lons;
+                std::vector<int32_t> m_tags;
+
+                osmium::util::DeltaEncode<object_id_type, int64_t> m_delta_id;
+
+                osmium::util::DeltaEncode<uint32_t, int64_t> m_delta_timestamp;
+                osmium::util::DeltaEncode<changeset_id_type, int64_t> m_delta_changeset;
+                osmium::util::DeltaEncode<user_id_type, int32_t> m_delta_uid;
+                osmium::util::DeltaEncode<uint32_t, int32_t> m_delta_user_sid;
+
+                osmium::util::DeltaEncode<int64_t, int64_t> m_delta_lat;
+                osmium::util::DeltaEncode<int64_t, int64_t> m_delta_lon;
+
+                const pbf_output_options& m_options;
+
+            public:
+
+                DenseNodes(StringTable& stringtable, const pbf_output_options& options) :
+                    m_stringtable(stringtable),
+                    m_options(options) {
+                }
+
+                /// Clear object for re-use. Keep the allocated memory.
+                void clear() {
+                    m_ids.clear();
+
+                    m_versions.clear();
+                    m_timestamps.clear();
+                    m_changesets.clear();
+                    m_uids.clear();
+                    m_user_sids.clear();
+                    m_visibles.clear();
+
+                    m_lats.clear();
+                    m_lons.clear();
+                    m_tags.clear();
+
+                    m_delta_id.clear();
+
+                    m_delta_timestamp.clear();
+                    m_delta_changeset.clear();
+                    m_delta_uid.clear();
+                    m_delta_user_sid.clear();
+
+                    m_delta_lat.clear();
+                    m_delta_lon.clear();
+                }
+
+                size_t size() const {
+                    return m_ids.size() * 3 * sizeof(int64_t);
+                }
+
+                void add_node(const osmium::Node& node) {
+                    m_ids.push_back(m_delta_id.update(node.id()));
+
+                    if (m_options.add_metadata) {
+                        m_versions.push_back(static_cast_with_assert<int32_t>(node.version()));
+                        m_timestamps.push_back(m_delta_timestamp.update(uint32_t(node.timestamp())));
+                        m_changesets.push_back(m_delta_changeset.update(node.changeset()));
+                        m_uids.push_back(m_delta_uid.update(node.uid()));
+                        m_user_sids.push_back(m_delta_user_sid.update(m_stringtable.add(node.user())));
+                        if (m_options.add_visible_flag) {
+                            m_visibles.push_back(node.visible());
+                        }
+                    }
+
+                    m_lats.push_back(m_delta_lat.update(lonlat2int(node.location().lat_without_check())));
+                    m_lons.push_back(m_delta_lon.update(lonlat2int(node.location().lon_without_check())));
+
+                    for (const auto& tag : node.tags()) {
+                        m_tags.push_back(static_cast_with_assert<int32_t>(m_stringtable.add(tag.key())));
+                        m_tags.push_back(static_cast_with_assert<int32_t>(m_stringtable.add(tag.value())));
+                    }
+                    m_tags.push_back(0);
+                }
+
+                std::string serialize() const {
+                    std::string data;
+                    protozero::pbf_builder<OSMFormat::DenseNodes> pbf_dense_nodes(data);
+
+                    pbf_dense_nodes.add_packed_sint64(OSMFormat::DenseNodes::packed_sint64_id, m_ids.cbegin(), m_ids.cend());
+
+                    if (m_options.add_metadata) {
+                        protozero::pbf_builder<OSMFormat::DenseInfo> pbf_dense_info(pbf_dense_nodes, OSMFormat::DenseNodes::optional_DenseInfo_denseinfo);
+                        pbf_dense_info.add_packed_int32(OSMFormat::DenseInfo::packed_int32_version, m_versions.cbegin(), m_versions.cend());
+                        pbf_dense_info.add_packed_sint64(OSMFormat::DenseInfo::packed_sint64_timestamp, m_timestamps.cbegin(), m_timestamps.cend());
+                        pbf_dense_info.add_packed_sint64(OSMFormat::DenseInfo::packed_sint64_changeset, m_changesets.cbegin(), m_changesets.cend());
+                        pbf_dense_info.add_packed_sint32(OSMFormat::DenseInfo::packed_sint32_uid, m_uids.cbegin(), m_uids.cend());
+                        pbf_dense_info.add_packed_sint32(OSMFormat::DenseInfo::packed_sint32_user_sid, m_user_sids.cbegin(), m_user_sids.cend());
+
+                        if (m_options.add_visible_flag) {
+                            pbf_dense_info.add_packed_bool(OSMFormat::DenseInfo::packed_bool_visible, m_visibles.cbegin(), m_visibles.cend());
+                        }
+                    }
+
+                    pbf_dense_nodes.add_packed_sint64(OSMFormat::DenseNodes::packed_sint64_lat, m_lats.cbegin(), m_lats.cend());
+                    pbf_dense_nodes.add_packed_sint64(OSMFormat::DenseNodes::packed_sint64_lon, m_lons.cbegin(), m_lons.cend());
+
+                    pbf_dense_nodes.add_packed_int32(OSMFormat::DenseNodes::packed_int32_keys_vals, m_tags.cbegin(), m_tags.cend());
+
+                    return data;
+                }
+
+            }; // class DenseNodes
+
+            class PrimitiveBlock {
+
+                std::string m_pbf_primitive_group_data;
+                protozero::pbf_builder<OSMFormat::PrimitiveGroup> m_pbf_primitive_group;
+                StringTable m_stringtable;
+                DenseNodes m_dense_nodes;
+                OSMFormat::PrimitiveGroup m_type;
+                int m_count;
+
+            public:
+
+                explicit PrimitiveBlock(const pbf_output_options& options) :
+                    m_pbf_primitive_group_data(),
+                    m_pbf_primitive_group(m_pbf_primitive_group_data),
+                    m_stringtable(),
+                    m_dense_nodes(m_stringtable, options),
+                    m_type(OSMFormat::PrimitiveGroup::unknown),
+                    m_count(0) {
+                }
+
+                const std::string& group_data() {
+                    if (type() == OSMFormat::PrimitiveGroup::optional_DenseNodes_dense) {
+                        m_pbf_primitive_group.add_message(OSMFormat::PrimitiveGroup::optional_DenseNodes_dense, m_dense_nodes.serialize());
+                    }
+                    return m_pbf_primitive_group_data;
+                }
+
+                void reset(OSMFormat::PrimitiveGroup type) {
+                    m_pbf_primitive_group_data.clear();
+                    m_stringtable.clear();
+                    m_dense_nodes.clear();
+                    m_type = type;
+                    m_count = 0;
+                }
+
+                void write_stringtable(protozero::pbf_builder<OSMFormat::StringTable>& pbf_string_table) {
+                    for (const char* s : m_stringtable) {
+                        pbf_string_table.add_bytes(OSMFormat::StringTable::repeated_bytes_s, s);
+                    }
+                }
+
+                protozero::pbf_builder<OSMFormat::PrimitiveGroup>& group() {
+                    ++m_count;
+                    return m_pbf_primitive_group;
+                }
+
+                void add_dense_node(const osmium::Node& node) {
+                    m_dense_nodes.add_node(node);
+                    ++m_count;
+                }
+
+                uint32_t store_in_stringtable(const char* s) {
+                    return m_stringtable.add(s);
+                }
+
+                int count() const {
+                    return m_count;
+                }
+
+                OSMFormat::PrimitiveGroup type() const {
+                    return m_type;
+                }
+
+                size_t size() const {
+                    return m_pbf_primitive_group_data.size() + m_stringtable.size() + m_dense_nodes.size();
+                }
+
+                /**
+                 * The output buffer (block) will be filled to about
+                 * 95% and then written to disk. This leaves more than
+                 * enough space for the string table (which typically
+                 * needs about 0.1 to 0.3% of the block size).
+                 */
+                constexpr static size_t max_used_blob_size = max_uncompressed_blob_size * 95 / 100;
+
+                bool can_add(OSMFormat::PrimitiveGroup type) const {
+                    if (type != m_type) {
+                        return false;
+                    }
+                    if (count() >= max_entities_per_block) {
+                        return false;
+                    }
+                    return size() < max_used_blob_size;
+                }
+
+            }; // class PrimitiveBlock
+
+            class PBFOutputFormat : public osmium::io::detail::OutputFormat, public osmium::handler::Handler {
+
+                pbf_output_options m_options;
+
+                PrimitiveBlock m_primitive_block;
+
+                void store_primitive_block() {
+                    if (m_primitive_block.count() == 0) {
+                        return;
+                    }
+
+                    std::string primitive_block_data;
+                    protozero::pbf_builder<OSMFormat::PrimitiveBlock> primitive_block(primitive_block_data);
+
+                    {
+                        protozero::pbf_builder<OSMFormat::StringTable> pbf_string_table(primitive_block, OSMFormat::PrimitiveBlock::required_StringTable_stringtable);
+                        m_primitive_block.write_stringtable(pbf_string_table);
+                    }
+
+                    primitive_block.add_message(OSMFormat::PrimitiveBlock::repeated_PrimitiveGroup_primitivegroup, m_primitive_block.group_data());
+
+                    m_output_queue.push(osmium::thread::Pool::instance().submit(
+                        SerializeBlob{std::move(primitive_block_data),
+                                      pbf_blob_type::data,
+                                      m_options.use_compression}
+                    ));
+                }
+
+                template <typename T>
+                void add_meta(const osmium::OSMObject& object, T& pbf_object) {
+                    {
+                        protozero::packed_field_uint32 field{pbf_object, protozero::pbf_tag_type(T::enum_type::packed_uint32_keys)};
+                        for (const auto& tag : object.tags()) {
+                            field.add_element(m_primitive_block.store_in_stringtable(tag.key()));
+                        }
+                    }
+
+                    {
+                        protozero::packed_field_uint32 field{pbf_object, protozero::pbf_tag_type(T::enum_type::packed_uint32_vals)};
+                        for (const auto& tag : object.tags()) {
+                            field.add_element(m_primitive_block.store_in_stringtable(tag.value()));
+                        }
+                    }
+
+                    if (m_options.add_metadata) {
+                        protozero::pbf_builder<OSMFormat::Info> pbf_info(pbf_object, T::enum_type::optional_Info_info);
+
+                        pbf_info.add_int32(OSMFormat::Info::optional_int32_version, static_cast_with_assert<int32_t>(object.version()));
+                        pbf_info.add_int64(OSMFormat::Info::optional_int64_timestamp, uint32_t(object.timestamp()));
+                        pbf_info.add_int64(OSMFormat::Info::optional_int64_changeset, object.changeset());
+                        pbf_info.add_int32(OSMFormat::Info::optional_int32_uid, static_cast_with_assert<int32_t>(object.uid()));
+                        pbf_info.add_uint32(OSMFormat::Info::optional_uint32_user_sid, m_primitive_block.store_in_stringtable(object.user()));
+                        if (m_options.add_visible_flag) {
+                            pbf_info.add_bool(OSMFormat::Info::optional_bool_visible, object.visible());
+                        }
+                    }
+                }
+
+                void switch_primitive_block_type(OSMFormat::PrimitiveGroup type) {
+                    if (!m_primitive_block.can_add(type)) {
+                        store_primitive_block();
+                        m_primitive_block.reset(type);
+                    }
+                }
+
+            public:
+
+                PBFOutputFormat(const osmium::io::File& file, future_string_queue_type& output_queue) :
+                    OutputFormat(output_queue),
+                    m_options(),
+                    m_primitive_block(m_options) {
+                    m_options.use_dense_nodes = file.is_not_false("pbf_dense_nodes");
+                    m_options.use_compression = file.get("pbf_compression") != "none" && file.is_not_false("pbf_compression");
+                    m_options.add_metadata = file.is_not_false("pbf_add_metadata") && file.is_not_false("add_metadata");
+                    m_options.add_historical_information_flag = file.has_multiple_object_versions();
+                    m_options.add_visible_flag = file.has_multiple_object_versions();
+                }
+
+                PBFOutputFormat(const PBFOutputFormat&) = delete;
+                PBFOutputFormat& operator=(const PBFOutputFormat&) = delete;
+
+                ~PBFOutputFormat() noexcept final = default;
+
+                void write_header(const osmium::io::Header& header) final {
+                    std::string data;
+                    protozero::pbf_builder<OSMFormat::HeaderBlock> pbf_header_block(data);
+
+                    if (!header.boxes().empty()) {
+                        protozero::pbf_builder<OSMFormat::HeaderBBox> pbf_header_bbox(pbf_header_block, OSMFormat::HeaderBlock::optional_HeaderBBox_bbox);
+
+                        osmium::Box box = header.joined_boxes();
+                        pbf_header_bbox.add_sint64(OSMFormat::HeaderBBox::required_sint64_left,   int64_t(box.bottom_left().lon() * lonlat_resolution));
+                        pbf_header_bbox.add_sint64(OSMFormat::HeaderBBox::required_sint64_right,  int64_t(box.top_right().lon()   * lonlat_resolution));
+                        pbf_header_bbox.add_sint64(OSMFormat::HeaderBBox::required_sint64_top,    int64_t(box.top_right().lat()   * lonlat_resolution));
+                        pbf_header_bbox.add_sint64(OSMFormat::HeaderBBox::required_sint64_bottom, int64_t(box.bottom_left().lat() * lonlat_resolution));
+                    }
+
+                    pbf_header_block.add_string(OSMFormat::HeaderBlock::repeated_string_required_features, "OsmSchema-V0.6");
+
+                    if (m_options.use_dense_nodes) {
+                        pbf_header_block.add_string(OSMFormat::HeaderBlock::repeated_string_required_features, "DenseNodes");
+                    }
+
+                    if (m_options.add_historical_information_flag) {
+                        pbf_header_block.add_string(OSMFormat::HeaderBlock::repeated_string_required_features, "HistoricalInformation");
+                    }
+
+                    pbf_header_block.add_string(OSMFormat::HeaderBlock::optional_string_writingprogram, header.get("generator"));
+
+                    std::string osmosis_replication_timestamp = header.get("osmosis_replication_timestamp");
+                    if (!osmosis_replication_timestamp.empty()) {
+                        osmium::Timestamp ts(osmosis_replication_timestamp.c_str());
+                        pbf_header_block.add_int64(OSMFormat::HeaderBlock::optional_int64_osmosis_replication_timestamp, uint32_t(ts));
+                    }
+
+                    std::string osmosis_replication_sequence_number = header.get("osmosis_replication_sequence_number");
+                    if (!osmosis_replication_sequence_number.empty()) {
+                        pbf_header_block.add_int64(OSMFormat::HeaderBlock::optional_int64_osmosis_replication_sequence_number, std::atoll(osmosis_replication_sequence_number.c_str()));
+                    }
+
+                    std::string osmosis_replication_base_url = header.get("osmosis_replication_base_url");
+                    if (!osmosis_replication_base_url.empty()) {
+                        pbf_header_block.add_string(OSMFormat::HeaderBlock::optional_string_osmosis_replication_base_url, osmosis_replication_base_url);
+                    }
+
+                    m_output_queue.push(osmium::thread::Pool::instance().submit(
+                        SerializeBlob{std::move(data),
+                                      pbf_blob_type::header,
+                                      m_options.use_compression}
+                        ));
+                }
+
+                void write_buffer(osmium::memory::Buffer&& buffer) final {
+                    osmium::apply(buffer.cbegin(), buffer.cend(), *this);
+                }
+
+                void write_end() final {
+                    store_primitive_block();
+                }
+
+                void node(const osmium::Node& node) {
+                    if (m_options.use_dense_nodes) {
+                        switch_primitive_block_type(OSMFormat::PrimitiveGroup::optional_DenseNodes_dense);
+                        m_primitive_block.add_dense_node(node);
+                        return;
+                    }
+
+                    switch_primitive_block_type(OSMFormat::PrimitiveGroup::repeated_Node_nodes);
+                    protozero::pbf_builder<OSMFormat::Node> pbf_node{ m_primitive_block.group(), OSMFormat::PrimitiveGroup::repeated_Node_nodes };
+
+                    pbf_node.add_sint64(OSMFormat::Node::required_sint64_id, node.id());
+                    add_meta(node, pbf_node);
+
+                    pbf_node.add_sint64(OSMFormat::Node::required_sint64_lat, lonlat2int(node.location().lat_without_check()));
+                    pbf_node.add_sint64(OSMFormat::Node::required_sint64_lon, lonlat2int(node.location().lon_without_check()));
+                }
+
+                void way(const osmium::Way& way) {
+                    switch_primitive_block_type(OSMFormat::PrimitiveGroup::repeated_Way_ways);
+                    protozero::pbf_builder<OSMFormat::Way> pbf_way{ m_primitive_block.group(), OSMFormat::PrimitiveGroup::repeated_Way_ways };
+
+                    pbf_way.add_int64(OSMFormat::Way::required_int64_id, way.id());
+                    add_meta(way, pbf_way);
+
+                    static auto map_node_ref = [](osmium::NodeRefList::const_iterator node_ref) noexcept -> osmium::object_id_type {
+                        return node_ref->ref();
+                    };
+                    typedef osmium::util::DeltaEncodeIterator<osmium::NodeRefList::const_iterator, decltype(map_node_ref), osmium::object_id_type> it_type;
+
+                    const auto& nodes = way.nodes();
+                    it_type first { nodes.cbegin(), nodes.cend(), map_node_ref };
+                    it_type last { nodes.cend(), nodes.cend(), map_node_ref };
+                    pbf_way.add_packed_sint64(OSMFormat::Way::packed_sint64_refs, first, last);
+                }
+
+                void relation(const osmium::Relation& relation) {
+                    switch_primitive_block_type(OSMFormat::PrimitiveGroup::repeated_Relation_relations);
+                    protozero::pbf_builder<OSMFormat::Relation> pbf_relation { m_primitive_block.group(), OSMFormat::PrimitiveGroup::repeated_Relation_relations };
+
+                    pbf_relation.add_int64(OSMFormat::Relation::required_int64_id, relation.id());
+                    add_meta(relation, pbf_relation);
+
+                    {
+                        protozero::packed_field_int32 field{pbf_relation, protozero::pbf_tag_type(OSMFormat::Relation::packed_int32_roles_sid)};
+                        for (const auto& member : relation.members()) {
+                            field.add_element(m_primitive_block.store_in_stringtable(member.role()));
+                        }
+                    }
+
+                    static auto map_member_ref = [](osmium::RelationMemberList::const_iterator member) noexcept -> osmium::object_id_type {
+                        return member->ref();
+                    };
+                    typedef osmium::util::DeltaEncodeIterator<osmium::RelationMemberList::const_iterator, decltype(map_member_ref), osmium::object_id_type> it_type;
+                    const auto& members = relation.members();
+                    it_type first { members.cbegin(), members.cend(), map_member_ref };
+                    it_type last { members.cend(), members.cend(), map_member_ref };
+                    pbf_relation.add_packed_sint64(OSMFormat::Relation::packed_sint64_memids, first, last);
+
+                    {
+                        protozero::packed_field_int32 field{pbf_relation, protozero::pbf_tag_type(OSMFormat::Relation::packed_MemberType_types)};
+                        for (const auto& member : relation.members()) {
+                            field.add_element(int32_t(osmium::item_type_to_nwr_index(member.type())));
+                        }
+                    }
+                }
+
+            }; // class PBFOutputFormat
+
+            // we want the register_output_format() function to run, setting
+            // the variable is only a side-effect, it will never be used
+            const bool registered_pbf_output = osmium::io::detail::OutputFormatFactory::instance().register_output_format(osmium::io::file_format::pbf,
+                [](const osmium::io::File& file, future_string_queue_type& output_queue) {
+                    return new osmium::io::detail::PBFOutputFormat(file, output_queue);
+            });
+
+            // dummy function to silence the unused variable warning from above
+            inline bool get_registered_pbf_output() noexcept {
+                return registered_pbf_output;
+            }
+
+        } // namespace detail
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_DETAIL_PBF_OUTPUT_FORMAT_HPP

third_party/libosmium/include/osmium/io/detail/protobuf_tags.hpp

@@ -0,0 +1,170 @@
+#ifndef OSMIUM_IO_DETAIL_PROTOBUF_TAGS_HPP
+#define OSMIUM_IO_DETAIL_PROTOBUF_TAGS_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <protozero/types.hpp>
+
+namespace osmium {
+
+    namespace io {
+
+        namespace detail {
+
+            // directly translated from
+            // https://github.com/scrosby/OSM-binary/blob/master/src/fileformat.proto
+
+            namespace FileFormat {
+
+                enum class Blob : protozero::pbf_tag_type {
+                    optional_bytes_raw       = 1,
+                    optional_int32_raw_size  = 2,
+                    optional_bytes_zlib_data = 3,
+                    optional_bytes_lzma_data = 4
+                };
+
+                enum class BlobHeader : protozero::pbf_tag_type {
+                    required_string_type     = 1,
+                    optional_bytes_indexdata = 2,
+                    required_int32_datasize  = 3
+                };
+
+            } // namespace FileFormat
+
+            // directly translated from
+            // https://github.com/scrosby/OSM-binary/blob/master/src/osmformat.proto
+
+            namespace OSMFormat {
+
+                enum class HeaderBlock : protozero::pbf_tag_type {
+                    optional_HeaderBBox_bbox          =  1,
+                    repeated_string_required_features =  4,
+                    repeated_string_optional_features =  5,
+                    optional_string_writingprogram    = 16,
+                    optional_string_source            = 17,
+                    optional_int64_osmosis_replication_timestamp       = 32,
+                    optional_int64_osmosis_replication_sequence_number = 33,
+                    optional_string_osmosis_replication_base_url       = 34
+                };
+
+                enum class HeaderBBox : protozero::pbf_tag_type {
+                    required_sint64_left   = 1,
+                    required_sint64_right  = 2,
+                    required_sint64_top    = 3,
+                    required_sint64_bottom = 4
+                };
+
+                enum class PrimitiveBlock : protozero::pbf_tag_type {
+                    required_StringTable_stringtable       =  1,
+                    repeated_PrimitiveGroup_primitivegroup =  2,
+                    optional_int32_granularity             = 17,
+                    optional_int32_date_granularity        = 18,
+                    optional_int64_lat_offset              = 19,
+                    optional_int64_lon_offset              = 20
+                };
+
+                enum class PrimitiveGroup : protozero::pbf_tag_type {
+                    unknown                       = 0,
+                    repeated_Node_nodes           = 1,
+                    optional_DenseNodes_dense     = 2,
+                    repeated_Way_ways             = 3,
+                    repeated_Relation_relations   = 4,
+                    repeated_ChangeSet_changesets = 5
+                };
+
+                enum class StringTable : protozero::pbf_tag_type {
+                    repeated_bytes_s = 1
+                };
+
+                enum class Info : protozero::pbf_tag_type {
+                    optional_int32_version   = 1,
+                    optional_int64_timestamp = 2,
+                    optional_int64_changeset = 3,
+                    optional_int32_uid       = 4,
+                    optional_uint32_user_sid = 5,
+                    optional_bool_visible    = 6
+                };
+
+                enum class DenseInfo : protozero::pbf_tag_type {
+                    packed_int32_version    = 1,
+                    packed_sint64_timestamp = 2,
+                    packed_sint64_changeset = 3,
+                    packed_sint32_uid       = 4,
+                    packed_sint32_user_sid  = 5,
+                    packed_bool_visible     = 6
+                };
+
+                enum class Node : protozero::pbf_tag_type {
+                    required_sint64_id  = 1,
+                    packed_uint32_keys  = 2,
+                    packed_uint32_vals  = 3,
+                    optional_Info_info  = 4,
+                    required_sint64_lat = 8,
+                    required_sint64_lon = 9
+                };
+
+                enum class DenseNodes : protozero::pbf_tag_type {
+                    packed_sint64_id             =  1,
+                    optional_DenseInfo_denseinfo =  5,
+                    packed_sint64_lat            =  8,
+                    packed_sint64_lon            =  9,
+                    packed_int32_keys_vals       = 10
+                };
+
+                enum class Way : protozero::pbf_tag_type {
+                    required_int64_id  = 1,
+                    packed_uint32_keys = 2,
+                    packed_uint32_vals = 3,
+                    optional_Info_info = 4,
+                    packed_sint64_refs = 8
+                };
+
+                enum class Relation : protozero::pbf_tag_type {
+                    required_int64_id       =  1,
+                    packed_uint32_keys      =  2,
+                    packed_uint32_vals      =  3,
+                    optional_Info_info      =  4,
+                    packed_int32_roles_sid  =  8,
+                    packed_sint64_memids    =  9,
+                    packed_MemberType_types = 10
+                };
+
+            } // namespace OSMFormat
+
+        } // namespace detail
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif //  OSMIUM_IO_DETAIL_PROTOBUF_TAGS_HPP

third_party/libosmium/include/osmium/io/detail/queue_util.hpp

@@ -0,0 +1,157 @@
+#ifndef OSMIUM_IO_DETAIL_QUEUE_UTIL_HPP
+#define OSMIUM_IO_DETAIL_QUEUE_UTIL_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <algorithm>
+#include <exception>
+#include <future>
+#include <string>
+
+#include <osmium/memory/buffer.hpp>
+#include <osmium/thread/queue.hpp>
+
+namespace osmium {
+
+    namespace io {
+
+        namespace detail {
+
+            /**
+             * This type of queue contains buffers with OSM data in them.
+             * The "end of file" is marked by an invalid Buffer.
+             * The buffers are wrapped in a std::future so that they can also
+             * transport exceptions. The future also helps with keeping the
+             * data in order.
+             */
+            using future_buffer_queue_type = osmium::thread::Queue<std::future<osmium::memory::Buffer>>;
+
+            /**
+             * This type of queue contains OSM file data in the form it is
+             * stored on disk, ie encoded as XML, PBF, etc.
+             * The "end of file" is marked by an empty string.
+             */
+            using string_queue_type = osmium::thread::Queue<std::string>;
+
+            /**
+             * This type of queue contains OSM file data in the form it is
+             * stored on disk, ie encoded as XML, PBF, etc.
+             * The "end of file" is marked by an empty string.
+             * The strings are wrapped in a std::future so that they can also
+             * transport exceptions. The future also helps with keeping the
+             * data in order.
+             */
+            using future_string_queue_type = osmium::thread::Queue<std::future<std::string>>;
+
+            template <typename T>
+            inline void add_to_queue(osmium::thread::Queue<std::future<T>>& queue, T&& data) {
+                std::promise<T> promise;
+                queue.push(promise.get_future());
+                promise.set_value(std::forward<T>(data));
+            }
+
+            template <typename T>
+            inline void add_to_queue(osmium::thread::Queue<std::future<T>>& queue, std::exception_ptr&& exception) {
+                std::promise<T> promise;
+                queue.push(promise.get_future());
+                promise.set_exception(std::move(exception));
+            }
+
+            template <typename T>
+            inline void add_end_of_data_to_queue(osmium::thread::Queue<std::future<T>>& queue) {
+                add_to_queue<T>(queue, T{});
+            }
+
+            inline bool at_end_of_data(const std::string& data) {
+                return data.empty();
+            }
+
+            inline bool at_end_of_data(osmium::memory::Buffer& buffer) {
+                return !buffer;
+            }
+
+            template <typename T>
+            class queue_wrapper {
+
+                using queue_type = osmium::thread::Queue<std::future<T>>;
+
+                queue_type& m_queue;
+                bool m_has_reached_end_of_data;
+
+            public:
+
+                explicit queue_wrapper(queue_type& queue) :
+                    m_queue(queue),
+                    m_has_reached_end_of_data(false) {
+                }
+
+                ~queue_wrapper() noexcept {
+                    drain();
+                }
+
+                void drain() {
+                    while (!m_has_reached_end_of_data) {
+                        try {
+                            pop();
+                        } catch (...) {
+                            // Ignore any exceptions.
+                        }
+                    }
+                }
+
+                bool has_reached_end_of_data() const noexcept {
+                    return m_has_reached_end_of_data;
+                }
+
+                T pop() {
+                    T data;
+                    if (!m_has_reached_end_of_data) {
+                        std::future<T> data_future;
+                        m_queue.wait_and_pop(data_future);
+                        data = std::move(data_future.get());
+                        if (at_end_of_data(data)) {
+                            m_has_reached_end_of_data = true;
+                        }
+                    }
+                    return data;
+                }
+
+            }; // class queue_wrapper
+
+        } // namespace detail
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_DETAIL_QUEUE_UTIL_HPP

third_party/libosmium/include/osmium/io/detail/read_thread.hpp

@@ -0,0 +1,133 @@
+#ifndef OSMIUM_IO_DETAIL_READ_THREAD_HPP
+#define OSMIUM_IO_DETAIL_READ_THREAD_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <atomic>
+#include <exception>
+#include <string>
+#include <thread>
+#include <utility>
+
+#include <osmium/io/compression.hpp>
+#include <osmium/io/detail/queue_util.hpp>
+#include <osmium/thread/util.hpp>
+
+namespace osmium {
+
+    namespace io {
+
+        namespace detail {
+
+            /**
+             * This code uses an internally managed thread to read data from
+             * the input file and (optionally) decompress it. The result is
+             * sent to the given queue. Any exceptions will also be send to
+             * the queue.
+             */
+            class ReadThreadManager {
+
+                // only used in the sub-thread
+                osmium::io::Decompressor& m_decompressor;
+                future_string_queue_type& m_queue;
+
+                // used in both threads
+                std::atomic<bool> m_done;
+
+                // only used in the main thread
+                std::thread m_thread;
+
+                void run_in_thread() {
+                    osmium::thread::set_thread_name("_osmium_read");
+
+                    try {
+                        while (!m_done) {
+                            std::string data {m_decompressor.read()};
+                            if (at_end_of_data(data)) {
+                                break;
+                            }
+                            add_to_queue(m_queue, std::move(data));
+                        }
+
+                        m_decompressor.close();
+                    } catch (...) {
+                        add_to_queue(m_queue, std::current_exception());
+                    }
+
+                    add_end_of_data_to_queue(m_queue);
+                }
+
+            public:
+
+                ReadThreadManager(osmium::io::Decompressor& decompressor,
+                                  future_string_queue_type& queue) :
+                    m_decompressor(decompressor),
+                    m_queue(queue),
+                    m_done(false),
+                    m_thread(std::thread(&ReadThreadManager::run_in_thread, this)) {
+                }
+
+                ReadThreadManager(const ReadThreadManager&) = delete;
+                ReadThreadManager& operator=(const ReadThreadManager&) = delete;
+
+                ReadThreadManager(ReadThreadManager&&) = delete;
+                ReadThreadManager& operator=(ReadThreadManager&&) = delete;
+
+                ~ReadThreadManager() noexcept {
+                    try {
+                        close();
+                    } catch (...) {
+                        // Ignore any exceptions because destructor must not throw.
+                    }
+                }
+
+                void stop() noexcept {
+                    m_done = true;
+                }
+
+                void close() {
+                    stop();
+                    if (m_thread.joinable()) {
+                        m_thread.join();
+                    }
+                }
+
+            }; // class ReadThreadManager
+
+        } // namespace detail
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_DETAIL_READ_THREAD_HPP

third_party/libosmium/include/osmium/io/detail/read_write.hpp

@@ -0,0 +1,180 @@
+#ifndef OSMIUM_IO_DETAIL_READ_WRITE_HPP
+#define OSMIUM_IO_DETAIL_READ_WRITE_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <cerrno>
+#include <cstddef>
+#include <errno.h>
+#include <fcntl.h>
+#include <string>
+#include <system_error>
+
+#ifndef _MSC_VER
+# include <unistd.h>
+#else
+# include <io.h>
+#endif
+
+#include <osmium/io/writer_options.hpp>
+
+namespace osmium {
+
+    namespace io {
+
+        /**
+         * @brief Namespace for Osmium internal use
+         */
+        namespace detail {
+
+            /**
+             * Open file for writing. If the file exists, it is truncated, if
+             * not, it is created. If the file name is empty or "-", no file
+             * is opened and the stdout file descriptor (1) is returned.
+             *
+             * @param filename Name of file to be opened.
+             * @param allow_overwrite If the file exists, should it be overwritten?
+             * @returns File descriptor of open file.
+             * @throws system_error if the file can't be opened.
+             */
+            inline int open_for_writing(const std::string& filename, osmium::io::overwrite allow_overwrite = osmium::io::overwrite::no) {
+                if (filename == "" || filename == "-") {
+#ifdef _WIN32
+                    _setmode(1, _O_BINARY);
+#endif
+                    return 1; // stdout
+                }
+
+                int flags = O_WRONLY | O_CREAT;
+                if (allow_overwrite == osmium::io::overwrite::allow) {
+                    flags |= O_TRUNC;
+                } else {
+                    flags |= O_EXCL;
+                }
+#ifdef _WIN32
+                flags |= O_BINARY;
+#endif
+                int fd = ::open(filename.c_str(), flags, 0666);
+                if (fd < 0) {
+                    throw std::system_error(errno, std::system_category(), std::string("Open failed for '") + filename + "'");
+                }
+                return fd;
+            }
+
+            /**
+             * Open file for reading. If the file name is empty or "-", no file
+             * is opened and the stdin file descriptor (0) is returned.
+             *
+             * @param filename Name of file to be opened.
+             * @returns File descriptor of open file.
+             * @throws system_error if the file can't be opened.
+             */
+            inline int open_for_reading(const std::string& filename) {
+                if (filename == "" || filename == "-") {
+                    return 0; // stdin
+                }
+
+                int flags = O_RDONLY;
+#ifdef _WIN32
+                flags |= O_BINARY;
+#endif
+                int fd = ::open(filename.c_str(), flags);
+                if (fd < 0) {
+                    throw std::system_error(errno, std::system_category(), std::string("Open failed for '") + filename + "'");
+                }
+                return fd;
+            }
+
+            /**
+             * Writes the given number of bytes from the output_buffer to the file descriptor.
+             * This is just a wrapper around write(2), because write(2) can write less than
+             * the given number of bytes.
+             *
+             * @param fd File descriptor.
+             * @param output_buffer Buffer with data to be written. Must be at least size bytes long.
+             * @param size Number of bytes to write.
+             * @throws std::system_error On error.
+             */
+            inline void reliable_write(const int fd, const unsigned char* output_buffer, const size_t size) {
+                constexpr size_t max_write = 100L * 1024L * 1024L; // Max 100 MByte per write
+                size_t offset = 0;
+                do {
+                    auto write_count = size - offset;
+                    if (write_count > max_write) {
+                        write_count = max_write;
+                    }
+                    auto length = ::write(fd, output_buffer + offset, static_cast<unsigned int>(write_count));
+                    if (length < 0) {
+                        throw std::system_error(errno, std::system_category(), "Write failed");
+                    }
+                    offset += static_cast<size_t>(length);
+                } while (offset < size);
+            }
+
+            /**
+             * Writes the given number of bytes from the output_buffer to the file descriptor.
+             * This is just a wrapper around write(2), because write(2) can write less than
+             * the given number of bytes.
+             *
+             * @param fd File descriptor.
+             * @param output_buffer Buffer with data to be written. Must be at least size bytes long.
+             * @param size Number of bytes to write.
+             * @throws std::system_error On error.
+             */
+            inline void reliable_write(const int fd, const char* output_buffer, const size_t size) {
+                reliable_write(fd, reinterpret_cast<const unsigned char*>(output_buffer), size);
+            }
+
+            inline void reliable_fsync(const int fd) {
+#ifdef _WIN32
+                if (_commit(fd) != 0) {
+#else
+                if (::fsync(fd) != 0) {
+#endif
+                    throw std::system_error(errno, std::system_category(), "Fsync failed");
+                }
+            }
+
+            inline void reliable_close(const int fd) {
+                if (::close(fd) != 0) {
+                    throw std::system_error(errno, std::system_category(), "Close failed");
+                }
+            }
+
+        } // namespace detail
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_DETAIL_READ_WRITE_HPP

third_party/libosmium/include/osmium/io/detail/string_table.hpp

@@ -0,0 +1,265 @@
+#ifndef OSMIUM_IO_DETAIL_STRING_TABLE_HPP
+#define OSMIUM_IO_DETAIL_STRING_TABLE_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <iterator>
+#include <list>
+#include <map>
+#include <string>
+
+#include <osmium/io/detail/pbf.hpp>
+
+namespace osmium {
+
+    namespace io {
+
+        namespace detail {
+
+            /**
+             * class StringStore
+             *
+             * Storage of lots of strings (const char *). Memory is allocated in chunks.
+             * If a string is added and there is no space in the current chunk, a new
+             * chunk will be allocated. Strings added to the store must not be larger
+             * than the chunk size.
+             *
+             * All memory is released when the destructor is called. There is no other way
+             * to release all or part of the memory.
+             *
+             */
+            class StringStore {
+
+                size_t m_chunk_size;
+
+                std::list<std::string> m_chunks;
+
+                void add_chunk() {
+                    m_chunks.push_front(std::string());
+                    m_chunks.front().reserve(m_chunk_size);
+                }
+
+            public:
+
+                explicit StringStore(size_t chunk_size) :
+                    m_chunk_size(chunk_size),
+                    m_chunks() {
+                    add_chunk();
+                }
+
+                void clear() noexcept {
+                    m_chunks.erase(std::next(m_chunks.begin()), m_chunks.end());
+                    m_chunks.front().clear();
+                }
+
+                /**
+                 * Add a null terminated string to the store. This will
+                 * automatically get more memory if we are out.
+                 * Returns a pointer to the copy of the string we have
+                 * allocated.
+                 */
+                const char* add(const char* string) {
+                    size_t len = std::strlen(string) + 1;
+
+                    assert(len <= m_chunk_size);
+
+                    size_t chunk_len = m_chunks.front().size();
+                    if (chunk_len + len > m_chunks.front().capacity()) {
+                        add_chunk();
+                        chunk_len = 0;
+                    }
+
+                    m_chunks.front().append(string);
+                    m_chunks.front().append(1, '\0');
+
+                    return m_chunks.front().c_str() + chunk_len;
+                }
+
+                class const_iterator : public std::iterator<std::forward_iterator_tag, const char*> {
+
+                    typedef std::list<std::string>::const_iterator it_type;
+                    it_type m_it;
+                    const it_type m_last;
+                    const char* m_pos;
+
+                public:
+
+                    const_iterator(it_type it, it_type last) :
+                        m_it(it),
+                        m_last(last),
+                        m_pos(it == last ? nullptr : m_it->c_str()) {
+                    }
+
+                    const_iterator& operator++() {
+                        assert(m_it != m_last);
+                        auto last_pos = m_it->c_str() + m_it->size();
+                        while (m_pos != last_pos && *m_pos) ++m_pos;
+                        if (m_pos != last_pos) ++m_pos;
+                        if (m_pos == last_pos) {
+                            ++m_it;
+                            if (m_it != m_last) {
+                                m_pos = m_it->c_str();
+                            } else {
+                                m_pos = nullptr;
+                            }
+                        }
+                        return *this;
+                    }
+
+                    const_iterator operator++(int) {
+                        const_iterator tmp(*this);
+                        operator++();
+                        return tmp;
+                    }
+
+                    bool operator==(const const_iterator& rhs) const {
+                        return m_it == rhs.m_it && m_pos == rhs.m_pos;
+                    }
+
+                    bool operator!=(const const_iterator& rhs) const {
+                        return !(*this == rhs);
+                    }
+
+                    const char* operator*() const {
+                        assert(m_it != m_last);
+                        assert(m_pos != nullptr);
+                        return m_pos;
+                    }
+
+                }; // class const_iterator
+
+                const_iterator begin() const {
+                    if (m_chunks.front().empty()) {
+                        return end();
+                    }
+                    return const_iterator(m_chunks.begin(), m_chunks.end());
+                }
+
+                const_iterator end() const {
+                    return const_iterator(m_chunks.end(), m_chunks.end());
+                }
+
+                // These functions get you some idea how much memory was
+                // used.
+                size_t get_chunk_size() const noexcept {
+                    return m_chunk_size;
+                }
+
+                size_t get_chunk_count() const noexcept {
+                    return m_chunks.size();
+                }
+
+                size_t get_used_bytes_in_last_chunk() const noexcept {
+                    return m_chunks.front().size();
+                }
+
+            }; // class StringStore
+
+            struct StrComp {
+
+                bool operator()(const char* lhs, const char* rhs) const {
+                    return strcmp(lhs, rhs) < 0;
+                }
+
+            }; // struct StrComp
+
+            class StringTable {
+
+                // This is the maximum number of entries in a string table.
+                // This should never be reached in practice but we better
+                // make sure it doesn't. If we had max_uncompressed_blob_size
+                // many entries, we are sure they would never fit into a PBF
+                // Blob.
+                static constexpr const uint32_t max_entries = max_uncompressed_blob_size;
+
+                StringStore m_strings;
+                std::map<const char*, size_t, StrComp> m_index;
+                uint32_t m_size;
+
+            public:
+
+                StringTable() :
+                    m_strings(1024 * 1024),
+                    m_index(),
+                    m_size(0) {
+                    m_strings.add("");
+                }
+
+                void clear() {
+                    m_strings.clear();
+                    m_index.clear();
+                    m_size = 0;
+                    m_strings.add("");
+                }
+
+                uint32_t size() const noexcept {
+                    return m_size + 1;
+                }
+
+                uint32_t add(const char* s) {
+                    auto f = m_index.find(s);
+                    if (f != m_index.end()) {
+                        return uint32_t(f->second);
+                    }
+
+                    const char* cs = m_strings.add(s);
+                    m_index[cs] = ++m_size;
+
+                    if (m_size > max_entries) {
+                        throw osmium::pbf_error("string table has too many entries");
+                    }
+
+                    return m_size;
+                }
+
+                StringStore::const_iterator begin() const {
+                    return m_strings.begin();
+                }
+
+                StringStore::const_iterator end() const {
+                    return m_strings.end();
+                }
+
+            }; // class StringTable
+
+        } // namespace detail
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_DETAIL_STRING_TABLE_HPP

third_party/libosmium/include/osmium/io/detail/string_util.hpp

@@ -0,0 +1,209 @@
+#ifndef OSMIUM_IO_DETAIL_STRING_UTIL_HPP
+#define OSMIUM_IO_DETAIL_STRING_UTIL_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <cstdint>
+#include <cstring>
+#include <string>
+#include <utility>
+
+#include <utf8.h>
+
+namespace osmium {
+
+    namespace io {
+
+        namespace detail {
+
+#ifndef _MSC_VER
+# define SNPRINTF std::snprintf
+#else
+# define SNPRINTF _snprintf
+#endif
+
+            template <typename... TArgs>
+            inline int string_snprintf(std::string& out,
+                                       size_t old_size,
+                                       size_t max_size,
+                                       const char* format,
+                                       TArgs&&... args) {
+                out.resize(old_size + max_size);
+
+                return SNPRINTF(max_size ? const_cast<char*>(out.c_str()) + old_size : nullptr,
+                                max_size,
+                                format,
+                                std::forward<TArgs>(args)...);
+            }
+
+#undef SNPRINTF
+
+            /**
+             * This is a helper function for writing printf-like formatted
+             * data into a std::string.
+             *
+             * @param out The data will be appended to this string.
+             * @param format A string with formatting instructions a la printf.
+             * @param args Any further arguments like in printf.
+             * @throws std::bad_alloc If the string needed to grow and there
+             *         wasn't enough memory.
+             */
+            template <typename... TArgs>
+            inline void append_printf_formatted_string(std::string& out,
+                                                   const char* format,
+                                                   TArgs&&... args) {
+
+                // First try to write string with the max_size, if that doesn't
+                // work snprintf will tell us how much space it needs. We
+                // reserve that much space and try again. So this will always
+                // work, even if the output is larger than the given max_size.
+                //
+                // Unfortunately this trick doesn't work on Windows, because
+                // the _snprintf() function there only returns the length it
+                // needs if max_size==0 and the buffer pointer is the null
+                // pointer. So we have to take this into account.
+
+#ifndef _MSC_VER
+                static const size_t max_size = 100;
+#else
+                static const size_t max_size = 0;
+#endif
+
+                size_t old_size = out.size();
+
+                int len = string_snprintf(out,
+                                          old_size,
+                                          max_size,
+                                          format,
+                                          std::forward<TArgs>(args)...);
+                assert(len > 0);
+
+                if (size_t(len) >= max_size) {
+#ifndef NDEBUG
+                    int len2 =
+#endif
+                               string_snprintf(out,
+                                               old_size,
+                                               size_t(len) + 1,
+                                               format,
+                                               std::forward<TArgs>(args)...);
+                    assert(len2 == len);
+                }
+
+                out.resize(old_size + size_t(len));
+            }
+
+            inline void append_utf8_encoded_string(std::string& out, const char* data) {
+                const char* end = data + std::strlen(data);
+
+                while (data != end) {
+                    const char* last = data;
+                    uint32_t c = utf8::next(data, end);
+
+                    // This is a list of Unicode code points that we let
+                    // through instead of escaping them. It is incomplete
+                    // and can be extended later.
+                    // Generally we don't want to let through any character
+                    // that has special meaning in the OPL format such as
+                    // space, comma, @, etc. and any non-printing characters.
+                    if ((0x0021 <= c && c <= 0x0024) ||
+                        (0x0026 <= c && c <= 0x002b) ||
+                        (0x002d <= c && c <= 0x003c) ||
+                        (0x003e <= c && c <= 0x003f) ||
+                        (0x0041 <= c && c <= 0x007e) ||
+                        (0x00a1 <= c && c <= 0x00ac) ||
+                        (0x00ae <= c && c <= 0x05ff)) {
+                        out.append(last, data);
+                    } else {
+                        out += '%';
+                        if (c <= 0xff) {
+                            append_printf_formatted_string(out, "%02x", c);
+                        } else {
+                            append_printf_formatted_string(out, "%04x", c);
+                        }
+                        out += '%';
+                    }
+                }
+            }
+
+            inline void append_xml_encoded_string(std::string& out, const char* data) {
+                for (; *data != '\0'; ++data) {
+                    switch(*data) {
+                        case '&':  out += "&amp;";  break;
+                        case '\"': out += "&quot;"; break;
+                        case '\'': out += "&apos;"; break;
+                        case '<':  out += "&lt;";   break;
+                        case '>':  out += "&gt;";   break;
+                        case '\n': out += "&#xA;";  break;
+                        case '\r': out += "&#xD;";  break;
+                        case '\t': out += "&#x9;";  break;
+                        default:   out += *data;    break;
+                    }
+                }
+            }
+
+            inline void append_debug_encoded_string(std::string& out, const char* data, const char* prefix, const char* suffix) {
+                const char* end = data + std::strlen(data);
+
+                while (data != end) {
+                    const char* last = data;
+                    uint32_t c = utf8::next(data, end);
+
+                    // This is a list of Unicode code points that we let
+                    // through instead of escaping them. It is incomplete
+                    // and can be extended later.
+                    // Generally we don't want to let through any
+                    // non-printing characters.
+                    if ((0x0020 <= c && c <= 0x0021) ||
+                        (0x0023 <= c && c <= 0x003b) ||
+                        (0x003d == c) ||
+                        (0x003f <= c && c <= 0x007e) ||
+                        (0x00a1 <= c && c <= 0x00ac) ||
+                        (0x00ae <= c && c <= 0x05ff)) {
+                        out.append(last, data);
+                    } else {
+                        out.append(prefix);
+                        append_printf_formatted_string(out, "<U+%04X>", c);
+                        out.append(suffix);
+                    }
+                }
+            }
+
+        } // namespace detail
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_DETAIL_STRING_UTIL_HPP

third_party/libosmium/include/osmium/io/detail/write_thread.hpp

@@ -0,0 +1,107 @@
+#ifndef OSMIUM_IO_DETAIL_WRITE_THREAD_HPP
+#define OSMIUM_IO_DETAIL_WRITE_THREAD_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <algorithm>
+#include <exception>
+#include <future>
+#include <string>
+
+#include <osmium/io/compression.hpp>
+#include <osmium/io/detail/queue_util.hpp>
+#include <osmium/thread/util.hpp>
+
+namespace osmium {
+
+    namespace io {
+
+        namespace detail {
+
+            /**
+             * This codes runs in its own thread, getting data from the given
+             * queue, (optionally) compressing it, and writing it to the output
+             * file.
+             */
+            class WriteThread {
+
+                queue_wrapper<std::string> m_queue;
+                std::unique_ptr<osmium::io::Compressor> m_compressor;
+                std::promise<bool> m_promise;
+
+            public:
+
+                WriteThread(future_string_queue_type& input_queue,
+                            std::unique_ptr<osmium::io::Compressor>&& compressor,
+                            std::promise<bool>&& promise) :
+                    m_queue(input_queue),
+                    m_compressor(std::move(compressor)),
+                    m_promise(std::move(promise)) {
+                }
+
+                WriteThread(const WriteThread&) = delete;
+                WriteThread& operator=(const WriteThread&) = delete;
+
+                WriteThread(WriteThread&&) = delete;
+                WriteThread& operator=(WriteThread&&) = delete;
+
+                ~WriteThread() noexcept = default;
+
+                void operator()() {
+                    osmium::thread::set_thread_name("_osmium_write");
+
+                    try {
+                        while (true) {
+                            std::string data = m_queue.pop();
+                            if (at_end_of_data(data)) {
+                                break;
+                            }
+                            m_compressor->write(data);
+                        }
+                        m_compressor->close();
+                        m_promise.set_value(true);
+                    } catch (...) {
+                        m_promise.set_exception(std::current_exception());
+                        m_queue.drain();
+                    }
+                }
+
+            }; // class WriteThread
+
+        } // namespace detail
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_DETAIL_WRITE_THREAD_HPP

third_party/libosmium/include/osmium/io/detail/xml_input_format.hpp

@@ -0,0 +1,679 @@
+#ifndef OSMIUM_IO_DETAIL_XML_INPUT_FORMAT_HPP
+#define OSMIUM_IO_DETAIL_XML_INPUT_FORMAT_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <cstdlib>
+#include <cstring>
+#include <exception>
+#include <future>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include <expat.h>
+
+#include <osmium/builder/builder.hpp>
+#include <osmium/builder/osm_object_builder.hpp>
+#include <osmium/io/detail/input_format.hpp>
+#include <osmium/io/detail/queue_util.hpp>
+#include <osmium/io/error.hpp>
+#include <osmium/io/file_format.hpp>
+#include <osmium/io/header.hpp>
+#include <osmium/memory/buffer.hpp>
+#include <osmium/osm.hpp>
+#include <osmium/osm/box.hpp>
+#include <osmium/osm/entity_bits.hpp>
+#include <osmium/osm/item_type.hpp>
+#include <osmium/osm/location.hpp>
+#include <osmium/osm/object.hpp>
+#include <osmium/osm/types.hpp>
+#include <osmium/osm/types_from_string.hpp>
+#include <osmium/thread/queue.hpp>
+#include <osmium/thread/util.hpp>
+#include <osmium/util/cast.hpp>
+
+namespace osmium {
+
+    /**
+     * Exception thrown when the XML parser failed. The exception contains
+     * (if available) information about the place where the error happened
+     * and the type of error.
+     */
+    struct xml_error : public io_error {
+
+        unsigned long line;
+        unsigned long column;
+        XML_Error error_code;
+        std::string error_string;
+
+        explicit xml_error(XML_Parser parser) :
+            io_error(std::string("XML parsing error at line ")
+                    + std::to_string(XML_GetCurrentLineNumber(parser))
+                    + ", column "
+                    + std::to_string(XML_GetCurrentColumnNumber(parser))
+                    + ": "
+                    + XML_ErrorString(XML_GetErrorCode(parser))),
+            line(XML_GetCurrentLineNumber(parser)),
+            column(XML_GetCurrentColumnNumber(parser)),
+            error_code(XML_GetErrorCode(parser)),
+            error_string(XML_ErrorString(error_code)) {
+        }
+
+        explicit xml_error(const std::string& message) :
+            io_error(message),
+            line(0),
+            column(0),
+            error_code(),
+            error_string(message) {
+        }
+
+    }; // struct xml_error
+
+    /**
+     * Exception thrown when an OSM XML files contains no version attribute
+     * on the 'osm' element or if the version is unknown.
+     */
+    struct format_version_error : public io_error {
+
+        std::string version;
+
+        explicit format_version_error() :
+            io_error("Can not read file without version (missing version attribute on osm element)."),
+            version() {
+        }
+
+        explicit format_version_error(const char* v) :
+            io_error(std::string("Can not read file with version ") + v),
+            version(v) {
+        }
+
+    }; // struct format_version_error
+
+    namespace io {
+
+        namespace detail {
+
+            class XMLParser : public Parser {
+
+                static constexpr int buffer_size = 2 * 1000 * 1000;
+
+                enum class context {
+                    root,
+                    top,
+                    node,
+                    way,
+                    relation,
+                    changeset,
+                    discussion,
+                    comment,
+                    comment_text,
+                    ignored_node,
+                    ignored_way,
+                    ignored_relation,
+                    ignored_changeset,
+                    in_object
+                }; // enum class context
+
+                context m_context;
+                context m_last_context;
+
+                /**
+                 * This is used only for change files which contain create, modify,
+                 * and delete sections.
+                 */
+                bool m_in_delete_section;
+
+                osmium::io::Header m_header;
+
+                osmium::memory::Buffer m_buffer;
+
+                std::unique_ptr<osmium::builder::NodeBuilder>                m_node_builder;
+                std::unique_ptr<osmium::builder::WayBuilder>                 m_way_builder;
+                std::unique_ptr<osmium::builder::RelationBuilder>            m_relation_builder;
+                std::unique_ptr<osmium::builder::ChangesetBuilder>           m_changeset_builder;
+                std::unique_ptr<osmium::builder::ChangesetDiscussionBuilder> m_changeset_discussion_builder;
+
+                std::unique_ptr<osmium::builder::TagListBuilder>             m_tl_builder;
+                std::unique_ptr<osmium::builder::WayNodeListBuilder>         m_wnl_builder;
+                std::unique_ptr<osmium::builder::RelationMemberListBuilder>  m_rml_builder;
+
+                std::string m_comment_text;
+
+                /**
+                 * A C++ wrapper for the Expat parser that makes sure no memory is leaked.
+                 */
+                template <typename T>
+                class ExpatXMLParser {
+
+                    XML_Parser m_parser;
+
+                    static void XMLCALL start_element_wrapper(void* data, const XML_Char* element, const XML_Char** attrs) {
+                        static_cast<XMLParser*>(data)->start_element(element, attrs);
+                    }
+
+                    static void XMLCALL end_element_wrapper(void* data, const XML_Char* element) {
+                        static_cast<XMLParser*>(data)->end_element(element);
+                    }
+
+                    static void XMLCALL character_data_wrapper(void* data, const XML_Char* text, int len) {
+                        static_cast<XMLParser*>(data)->characters(text, len);
+                    }
+
+                public:
+
+                    explicit ExpatXMLParser(T* callback_object) :
+                        m_parser(XML_ParserCreate(nullptr)) {
+                        if (!m_parser) {
+                            throw osmium::io_error("Internal error: Can not create parser");
+                        }
+                        XML_SetUserData(m_parser, callback_object);
+                        XML_SetElementHandler(m_parser, start_element_wrapper, end_element_wrapper);
+                        XML_SetCharacterDataHandler(m_parser, character_data_wrapper);
+                    }
+
+                    ExpatXMLParser(const ExpatXMLParser&) = delete;
+                    ExpatXMLParser(ExpatXMLParser&&) = delete;
+
+                    ExpatXMLParser& operator=(const ExpatXMLParser&) = delete;
+                    ExpatXMLParser& operator=(ExpatXMLParser&&) = delete;
+
+                    ~ExpatXMLParser() noexcept {
+                        XML_ParserFree(m_parser);
+                    }
+
+                    void operator()(const std::string& data, bool last) {
+                        if (XML_Parse(m_parser, data.data(), static_cast_with_assert<int>(data.size()), last) == XML_STATUS_ERROR) {
+                            throw osmium::xml_error(m_parser);
+                        }
+                    }
+
+                }; // class ExpatXMLParser
+
+                template <typename T>
+                static void check_attributes(const XML_Char** attrs, T check) {
+                    while (*attrs) {
+                        check(attrs[0], attrs[1]);
+                        attrs += 2;
+                    }
+                }
+
+                const char* init_object(osmium::OSMObject& object, const XML_Char** attrs) {
+                    const char* user = "";
+
+                    if (m_in_delete_section) {
+                        object.set_visible(false);
+                    }
+
+                    osmium::Location location;
+
+                    check_attributes(attrs, [&location, &user, &object](const XML_Char* name, const XML_Char* value) {
+                        if (!strcmp(name, "lon")) {
+                            location.set_lon(std::atof(value)); // XXX doesn't detect garbage after the number
+                        } else if (!strcmp(name, "lat")) {
+                            location.set_lat(std::atof(value)); // XXX doesn't detect garbage after the number
+                        } else if (!strcmp(name, "user")) {
+                            user = value;
+                        } else {
+                            object.set_attribute(name, value);
+                        }
+                    });
+
+                    if (location && object.type() == osmium::item_type::node) {
+                        static_cast<osmium::Node&>(object).set_location(location);
+                    }
+
+                    return user;
+                }
+
+                void init_changeset(osmium::builder::ChangesetBuilder* builder, const XML_Char** attrs) {
+                    const char* user = "";
+                    osmium::Changeset& new_changeset = builder->object();
+
+                    osmium::Location min;
+                    osmium::Location max;
+                    check_attributes(attrs, [&min, &max, &user, &new_changeset](const XML_Char* name, const XML_Char* value) {
+                        if (!strcmp(name, "min_lon")) {
+                            min.set_lon(atof(value));
+                        } else if (!strcmp(name, "min_lat")) {
+                            min.set_lat(atof(value));
+                        } else if (!strcmp(name, "max_lon")) {
+                            max.set_lon(atof(value));
+                        } else if (!strcmp(name, "max_lat")) {
+                            max.set_lat(atof(value));
+                        } else if (!strcmp(name, "user")) {
+                            user = value;
+                        } else {
+                            new_changeset.set_attribute(name, value);
+                        }
+                    });
+
+                    new_changeset.bounds().extend(min);
+                    new_changeset.bounds().extend(max);
+
+                    builder->add_user(user);
+                }
+
+                void get_tag(osmium::builder::Builder* builder, const XML_Char** attrs) {
+                    const char* k = "";
+                    const char* v = "";
+                    check_attributes(attrs, [&k, &v](const XML_Char* name, const XML_Char* value) {
+                        if (name[0] == 'k' && name[1] == 0) {
+                            k = value;
+                        } else if (name[0] == 'v' && name[1] == 0) {
+                            v = value;
+                        }
+                    });
+                    if (!m_tl_builder) {
+                        m_tl_builder = std::unique_ptr<osmium::builder::TagListBuilder>(new osmium::builder::TagListBuilder(m_buffer, builder));
+                    }
+                    m_tl_builder->add_tag(k, v);
+                }
+
+                void mark_header_as_done() {
+                    set_header_value(m_header);
+                }
+
+                void start_element(const XML_Char* element, const XML_Char** attrs) {
+                    switch (m_context) {
+                        case context::root:
+                            if (!strcmp(element, "osm") || !strcmp(element, "osmChange")) {
+                                if (!strcmp(element, "osmChange")) {
+                                    m_header.set_has_multiple_object_versions(true);
+                                }
+                                check_attributes(attrs, [this](const XML_Char* name, const XML_Char* value) {
+                                    if (!strcmp(name, "version")) {
+                                        m_header.set("version", value);
+                                        if (strcmp(value, "0.6")) {
+                                            throw osmium::format_version_error(value);
+                                        }
+                                    } else if (!strcmp(name, "generator")) {
+                                        m_header.set("generator", value);
+                                    }
+                                });
+                                if (m_header.get("version") == "") {
+                                    throw osmium::format_version_error();
+                                }
+                            } else {
+                                throw osmium::xml_error(std::string("Unknown top-level element: ") + element);
+                            }
+                            m_context = context::top;
+                            break;
+                        case context::top:
+                            assert(!m_tl_builder);
+                            if (!strcmp(element, "node")) {
+                                mark_header_as_done();
+                                if (read_types() & osmium::osm_entity_bits::node) {
+                                    m_node_builder = std::unique_ptr<osmium::builder::NodeBuilder>(new osmium::builder::NodeBuilder(m_buffer));
+                                    m_node_builder->add_user(init_object(m_node_builder->object(), attrs));
+                                    m_context = context::node;
+                                } else {
+                                    m_context = context::ignored_node;
+                                }
+                            } else if (!strcmp(element, "way")) {
+                                mark_header_as_done();
+                                if (read_types() & osmium::osm_entity_bits::way) {
+                                    m_way_builder = std::unique_ptr<osmium::builder::WayBuilder>(new osmium::builder::WayBuilder(m_buffer));
+                                    m_way_builder->add_user(init_object(m_way_builder->object(), attrs));
+                                    m_context = context::way;
+                                } else {
+                                    m_context = context::ignored_way;
+                                }
+                            } else if (!strcmp(element, "relation")) {
+                                mark_header_as_done();
+                                if (read_types() & osmium::osm_entity_bits::relation) {
+                                    m_relation_builder = std::unique_ptr<osmium::builder::RelationBuilder>(new osmium::builder::RelationBuilder(m_buffer));
+                                    m_relation_builder->add_user(init_object(m_relation_builder->object(), attrs));
+                                    m_context = context::relation;
+                                } else {
+                                    m_context = context::ignored_relation;
+                                }
+                            } else if (!strcmp(element, "changeset")) {
+                                mark_header_as_done();
+                                if (read_types() & osmium::osm_entity_bits::changeset) {
+                                    m_changeset_builder = std::unique_ptr<osmium::builder::ChangesetBuilder>(new osmium::builder::ChangesetBuilder(m_buffer));
+                                    init_changeset(m_changeset_builder.get(), attrs);
+                                    m_context = context::changeset;
+                                } else {
+                                    m_context = context::ignored_changeset;
+                                }
+                            } else if (!strcmp(element, "bounds")) {
+                                osmium::Location min;
+                                osmium::Location max;
+                                check_attributes(attrs, [&min, &max](const XML_Char* name, const XML_Char* value) {
+                                    if (!strcmp(name, "minlon")) {
+                                        min.set_lon(atof(value));
+                                    } else if (!strcmp(name, "minlat")) {
+                                        min.set_lat(atof(value));
+                                    } else if (!strcmp(name, "maxlon")) {
+                                        max.set_lon(atof(value));
+                                    } else if (!strcmp(name, "maxlat")) {
+                                        max.set_lat(atof(value));
+                                    }
+                                });
+                                osmium::Box box;
+                                box.extend(min).extend(max);
+                                m_header.add_box(box);
+                            } else if (!strcmp(element, "delete")) {
+                                m_in_delete_section = true;
+                            }
+                            break;
+                        case context::node:
+                            m_last_context = context::node;
+                            m_context = context::in_object;
+                            if (!strcmp(element, "tag")) {
+                                get_tag(m_node_builder.get(), attrs);
+                            }
+                            break;
+                        case context::way:
+                            m_last_context = context::way;
+                            m_context = context::in_object;
+                            if (!strcmp(element, "nd")) {
+                                m_tl_builder.reset();
+
+                                if (!m_wnl_builder) {
+                                    m_wnl_builder = std::unique_ptr<osmium::builder::WayNodeListBuilder>(new osmium::builder::WayNodeListBuilder(m_buffer, m_way_builder.get()));
+                                }
+
+                                check_attributes(attrs, [this](const XML_Char* name, const XML_Char* value) {
+                                    if (!strcmp(name, "ref")) {
+                                        m_wnl_builder->add_node_ref(osmium::string_to_object_id(value));
+                                    }
+                                });
+                            } else if (!strcmp(element, "tag")) {
+                                m_wnl_builder.reset();
+                                get_tag(m_way_builder.get(), attrs);
+                            }
+                            break;
+                        case context::relation:
+                            m_last_context = context::relation;
+                            m_context = context::in_object;
+                            if (!strcmp(element, "member")) {
+                                m_tl_builder.reset();
+
+                                if (!m_rml_builder) {
+                                    m_rml_builder = std::unique_ptr<osmium::builder::RelationMemberListBuilder>(new osmium::builder::RelationMemberListBuilder(m_buffer, m_relation_builder.get()));
+                                }
+
+                                item_type type = item_type::undefined;
+                                object_id_type ref = 0;
+                                const char* role = "";
+                                check_attributes(attrs, [&type, &ref, &role](const XML_Char* name, const XML_Char* value) {
+                                    if (!strcmp(name, "type")) {
+                                        type = char_to_item_type(value[0]);
+                                    } else if (!strcmp(name, "ref")) {
+                                        ref = osmium::string_to_object_id(value);
+                                    } else if (!strcmp(name, "role")) {
+                                        role = static_cast<const char*>(value);
+                                    }
+                                });
+                                if (type != item_type::node && type != item_type::way && type != item_type::relation) {
+                                    throw osmium::xml_error("Unknown type on relation member");
+                                }
+                                if (ref == 0) {
+                                    throw osmium::xml_error("Missing ref on relation member");
+                                }
+                                m_rml_builder->add_member(type, ref, role);
+                            } else if (!strcmp(element, "tag")) {
+                                m_rml_builder.reset();
+                                get_tag(m_relation_builder.get(), attrs);
+                            }
+                            break;
+                        case context::changeset:
+                            m_last_context = context::changeset;
+                            if (!strcmp(element, "discussion")) {
+                                m_context = context::discussion;
+                                m_tl_builder.reset();
+                                if (!m_changeset_discussion_builder) {
+                                    m_changeset_discussion_builder = std::unique_ptr<osmium::builder::ChangesetDiscussionBuilder>(new osmium::builder::ChangesetDiscussionBuilder(m_buffer, m_changeset_builder.get()));
+                                }
+                            } else if (!strcmp(element, "tag")) {
+                                m_context = context::in_object;
+                                m_changeset_discussion_builder.reset();
+                                get_tag(m_changeset_builder.get(), attrs);
+                            }
+                            break;
+                        case context::discussion:
+                            if (!strcmp(element, "comment")) {
+                                m_context = context::comment;
+                                osmium::Timestamp date;
+                                osmium::user_id_type uid = 0;
+                                const char* user = "";
+                                check_attributes(attrs, [&date, &uid, &user](const XML_Char* name, const XML_Char* value) {
+                                    if (!strcmp(name, "date")) {
+                                        date = osmium::Timestamp(value);
+                                    } else if (!strcmp(name, "uid")) {
+                                        uid = osmium::string_to_user_id(value);
+                                    } else if (!strcmp(name, "user")) {
+                                        user = static_cast<const char*>(value);
+                                    }
+                                });
+                                m_changeset_discussion_builder->add_comment(date, uid, user);
+                            }
+                            break;
+                        case context::comment:
+                            if (!strcmp(element, "text")) {
+                                m_context = context::comment_text;
+                            }
+                            break;
+                        case context::comment_text:
+                            break;
+                        case context::ignored_node:
+                            break;
+                        case context::ignored_way:
+                            break;
+                        case context::ignored_relation:
+                            break;
+                        case context::ignored_changeset:
+                            break;
+                        case context::in_object:
+                            assert(false); // should never be here
+                            break;
+                    }
+                }
+
+                void end_element(const XML_Char* element) {
+                    switch (m_context) {
+                        case context::root:
+                            assert(false); // should never be here
+                            break;
+                        case context::top:
+                            if (!strcmp(element, "osm") || !strcmp(element, "osmChange")) {
+                                mark_header_as_done();
+                                m_context = context::root;
+                            } else if (!strcmp(element, "delete")) {
+                                m_in_delete_section = false;
+                            }
+                            break;
+                        case context::node:
+                            assert(!strcmp(element, "node"));
+                            m_tl_builder.reset();
+                            m_node_builder.reset();
+                            m_buffer.commit();
+                            m_context = context::top;
+                            flush_buffer();
+                            break;
+                        case context::way:
+                            assert(!strcmp(element, "way"));
+                            m_tl_builder.reset();
+                            m_wnl_builder.reset();
+                            m_way_builder.reset();
+                            m_buffer.commit();
+                            m_context = context::top;
+                            flush_buffer();
+                            break;
+                        case context::relation:
+                            assert(!strcmp(element, "relation"));
+                            m_tl_builder.reset();
+                            m_rml_builder.reset();
+                            m_relation_builder.reset();
+                            m_buffer.commit();
+                            m_context = context::top;
+                            flush_buffer();
+                            break;
+                        case context::changeset:
+                            assert(!strcmp(element, "changeset"));
+                            m_tl_builder.reset();
+                            m_changeset_discussion_builder.reset();
+                            m_changeset_builder.reset();
+                            m_buffer.commit();
+                            m_context = context::top;
+                            flush_buffer();
+                            break;
+                        case context::discussion:
+                            assert(!strcmp(element, "discussion"));
+                            m_context = context::changeset;
+                            break;
+                        case context::comment:
+                            assert(!strcmp(element, "comment"));
+                            m_context = context::discussion;
+                            break;
+                        case context::comment_text:
+                            assert(!strcmp(element, "text"));
+                            m_context = context::comment;
+                            m_changeset_discussion_builder->add_comment_text(m_comment_text);
+                            break;
+                        case context::in_object:
+                            m_context = m_last_context;
+                            break;
+                        case context::ignored_node:
+                            if (!strcmp(element, "node")) {
+                                m_context = context::top;
+                            }
+                            break;
+                        case context::ignored_way:
+                            if (!strcmp(element, "way")) {
+                                m_context = context::top;
+                            }
+                            break;
+                        case context::ignored_relation:
+                            if (!strcmp(element, "relation")) {
+                                m_context = context::top;
+                            }
+                            break;
+                        case context::ignored_changeset:
+                            if (!strcmp(element, "changeset")) {
+                                m_context = context::top;
+                            }
+                            break;
+                    }
+                }
+
+                void characters(const XML_Char* text, int len) {
+                    if (m_context == context::comment_text) {
+                        m_comment_text.append(text, len);
+                    } else {
+                        m_comment_text.resize(0);
+                    }
+                }
+
+                void flush_buffer() {
+                    if (m_buffer.committed() > buffer_size / 10 * 9) {
+                        send_to_output_queue(std::move(m_buffer));
+                        osmium::memory::Buffer buffer(buffer_size);
+                        using std::swap;
+                        swap(m_buffer, buffer);
+                    }
+                }
+
+            public:
+
+                XMLParser(future_string_queue_type& input_queue,
+                          future_buffer_queue_type& output_queue,
+                          std::promise<osmium::io::Header>& header_promise,
+                          osmium::osm_entity_bits::type read_types) :
+                    Parser(input_queue, output_queue, header_promise, read_types),
+                    m_context(context::root),
+                    m_last_context(context::root),
+                    m_in_delete_section(false),
+                    m_header(),
+                    m_buffer(buffer_size),
+                    m_node_builder(),
+                    m_way_builder(),
+                    m_relation_builder(),
+                    m_changeset_builder(),
+                    m_changeset_discussion_builder(),
+                    m_tl_builder(),
+                    m_wnl_builder(),
+                    m_rml_builder() {
+                }
+
+                ~XMLParser() noexcept final = default;
+
+                void run() final {
+                    osmium::thread::set_thread_name("_osmium_xml_in");
+
+                    ExpatXMLParser<XMLParser> parser(this);
+
+                    while (!input_done()) {
+                        std::string data = get_input();
+                        parser(data, input_done());
+                        if (read_types() == osmium::osm_entity_bits::nothing && header_is_done()) {
+                            break;
+                        }
+                    }
+
+                    mark_header_as_done();
+
+                    if (m_buffer.committed() > 0) {
+                        send_to_output_queue(std::move(m_buffer));
+                    }
+                }
+
+            }; // class XMLParser
+
+            // we want the register_parser() function to run, setting
+            // the variable is only a side-effect, it will never be used
+            const bool registered_xml_parser = ParserFactory::instance().register_parser(
+                file_format::xml,
+                [](future_string_queue_type& input_queue,
+                    future_buffer_queue_type& output_queue,
+                    std::promise<osmium::io::Header>& header_promise,
+                    osmium::osm_entity_bits::type read_which_entities) {
+                    return std::unique_ptr<Parser>(new XMLParser(input_queue, output_queue, header_promise, read_which_entities));
+            });
+
+            // dummy function to silence the unused variable warning from above
+            inline bool get_registered_xml_parser() noexcept {
+                return registered_xml_parser;
+            }
+
+        } // namespace detail
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_DETAIL_XML_INPUT_FORMAT_HPP

third_party/libosmium/include/osmium/io/detail/xml_output_format.hpp

@@ -0,0 +1,473 @@
+#ifndef OSMIUM_IO_DETAIL_XML_OUTPUT_FORMAT_HPP
+#define OSMIUM_IO_DETAIL_XML_OUTPUT_FORMAT_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <algorithm>
+#include <cinttypes>
+#include <cstddef>
+#include <cstdio>
+#include <future>
+#include <iterator>
+#include <memory>
+#include <string>
+#include <thread>
+#include <utility>
+
+#include <osmium/io/detail/output_format.hpp>
+#include <osmium/io/file.hpp>
+#include <osmium/io/file_format.hpp>
+#include <osmium/io/header.hpp>
+#include <osmium/memory/buffer.hpp>
+#include <osmium/memory/collection.hpp>
+#include <osmium/osm/box.hpp>
+#include <osmium/osm/changeset.hpp>
+#include <osmium/osm/item_type.hpp>
+#include <osmium/osm/location.hpp>
+#include <osmium/osm/node.hpp>
+#include <osmium/osm/object.hpp>
+#include <osmium/osm/relation.hpp>
+#include <osmium/osm/tag.hpp>
+#include <osmium/osm/timestamp.hpp>
+#include <osmium/osm/types.hpp>
+#include <osmium/osm/way.hpp>
+#include <osmium/thread/pool.hpp>
+#include <osmium/visitor.hpp>
+
+namespace osmium {
+
+    namespace io {
+
+        namespace detail {
+
+            struct XMLWriteError {};
+
+            struct xml_output_options {
+
+                /// Should metadata of objects be added?
+                bool add_metadata;
+
+                /// Should the visible flag be added to all OSM objects?
+                bool add_visible_flag;
+
+                /**
+                 * Should <create>, <modify>, <delete> "operations" be added?
+                 * (This is used for .osc files.)
+                 */
+                bool use_change_ops;
+
+            };
+
+            class XMLOutputBlock : public OutputBlock {
+
+                // operation (create, modify, delete) for osc files
+                enum class operation {
+                    op_none   = 0,
+                    op_create = 1,
+                    op_modify = 2,
+                    op_delete = 3
+                }; // enum class operation
+
+                operation m_last_op {operation::op_none};
+
+                xml_output_options m_options;
+
+                void write_spaces(int num) {
+                    for (; num != 0; --num) {
+                        *m_out += ' ';
+                    }
+                }
+
+                int prefix_spaces() {
+                    return m_options.use_change_ops ? 4 : 2;
+                }
+
+                void write_prefix() {
+                    write_spaces(prefix_spaces());
+                }
+
+                void write_meta(const osmium::OSMObject& object) {
+                    output_formatted(" id=\"%" PRId64 "\"", object.id());
+
+                    if (m_options.add_metadata) {
+                        if (object.version()) {
+                            output_formatted(" version=\"%d\"", object.version());
+                        }
+
+                        if (object.timestamp()) {
+                            *m_out += " timestamp=\"";
+                            *m_out += object.timestamp().to_iso();
+                            *m_out += "\"";
+                        }
+
+                        if (!object.user_is_anonymous()) {
+                            output_formatted(" uid=\"%d\" user=\"", object.uid());
+                            append_xml_encoded_string(*m_out, object.user());
+                            *m_out += "\"";
+                        }
+
+                        if (object.changeset()) {
+                            output_formatted(" changeset=\"%d\"", object.changeset());
+                        }
+
+                        if (m_options.add_visible_flag) {
+                            if (object.visible()) {
+                                *m_out += " visible=\"true\"";
+                            } else {
+                                *m_out += " visible=\"false\"";
+                            }
+                        }
+                    }
+                }
+
+                void write_tags(const osmium::TagList& tags, int spaces) {
+                    for (const auto& tag : tags) {
+                        write_spaces(spaces);
+                        *m_out += "  <tag k=\"";
+                        append_xml_encoded_string(*m_out, tag.key());
+                        *m_out += "\" v=\"";
+                        append_xml_encoded_string(*m_out, tag.value());
+                        *m_out += "\"/>\n";
+                    }
+                }
+
+                void write_discussion(const osmium::ChangesetDiscussion& comments) {
+                    for (const auto& comment : comments) {
+                        output_formatted("   <comment uid=\"%d\" user=\"", comment.uid());
+                        append_xml_encoded_string(*m_out, comment.user());
+                        *m_out += "\" date=\"";
+                        *m_out += comment.date().to_iso();
+                        *m_out += "\">\n";
+                        *m_out += "    <text>";
+                        append_xml_encoded_string(*m_out, comment.text());
+                        *m_out += "</text>\n   </comment>\n";
+                    }
+                    *m_out += "  </discussion>\n";
+                }
+
+                void open_close_op_tag(const operation op = operation::op_none) {
+                    if (op == m_last_op) {
+                        return;
+                    }
+
+                    switch (m_last_op) {
+                        case operation::op_none:
+                            break;
+                        case operation::op_create:
+                            *m_out += "  </create>\n";
+                            break;
+                        case operation::op_modify:
+                            *m_out += "  </modify>\n";
+                            break;
+                        case operation::op_delete:
+                            *m_out += "  </delete>\n";
+                            break;
+                    }
+
+                    switch (op) {
+                        case operation::op_none:
+                            break;
+                        case operation::op_create:
+                            *m_out += "  <create>\n";
+                            break;
+                        case operation::op_modify:
+                            *m_out += "  <modify>\n";
+                            break;
+                        case operation::op_delete:
+                            *m_out += "  <delete>\n";
+                            break;
+                    }
+
+                    m_last_op = op;
+                }
+
+            public:
+
+                XMLOutputBlock(osmium::memory::Buffer&& buffer, const xml_output_options& options) :
+                    OutputBlock(std::move(buffer)),
+                    m_options(options) {
+                }
+
+                XMLOutputBlock(const XMLOutputBlock&) = default;
+                XMLOutputBlock& operator=(const XMLOutputBlock&) = default;
+
+                XMLOutputBlock(XMLOutputBlock&&) = default;
+                XMLOutputBlock& operator=(XMLOutputBlock&&) = default;
+
+                ~XMLOutputBlock() noexcept = default;
+
+                std::string operator()() {
+                    osmium::apply(m_input_buffer->cbegin(), m_input_buffer->cend(), *this);
+
+                    if (m_options.use_change_ops) {
+                        open_close_op_tag();
+                    }
+
+                    std::string out;
+                    using std::swap;
+                    swap(out, *m_out);
+
+                    return out;
+                }
+
+                void node(const osmium::Node& node) {
+                    if (m_options.use_change_ops) {
+                        open_close_op_tag(node.visible() ? (node.version() == 1 ? operation::op_create : operation::op_modify) : operation::op_delete);
+                    }
+
+                    write_prefix();
+                    *m_out += "<node";
+
+                    write_meta(node);
+
+                    if (node.location()) {
+                        *m_out += " lat=\"";
+                        osmium::util::double2string(std::back_inserter(*m_out), node.location().lat_without_check(), 7);
+                        *m_out += "\" lon=\"";
+                        osmium::util::double2string(std::back_inserter(*m_out), node.location().lon_without_check(), 7);
+                        *m_out += "\"";
+                    }
+
+                    if (node.tags().empty()) {
+                        *m_out += "/>\n";
+                        return;
+                    }
+
+                    *m_out += ">\n";
+
+                    write_tags(node.tags(), prefix_spaces());
+
+                    write_prefix();
+                    *m_out += "</node>\n";
+                }
+
+                void way(const osmium::Way& way) {
+                    if (m_options.use_change_ops) {
+                        open_close_op_tag(way.visible() ? (way.version() == 1 ? operation::op_create : operation::op_modify) : operation::op_delete);
+                    }
+
+                    write_prefix();
+                    *m_out += "<way";
+                    write_meta(way);
+
+                    if (way.tags().empty() && way.nodes().empty()) {
+                        *m_out += "/>\n";
+                        return;
+                    }
+
+                    *m_out += ">\n";
+
+                    for (const auto& node_ref : way.nodes()) {
+                        write_prefix();
+                        output_formatted("  <nd ref=\"%" PRId64 "\"/>\n", node_ref.ref());
+                    }
+
+                    write_tags(way.tags(), prefix_spaces());
+
+                    write_prefix();
+                    *m_out += "</way>\n";
+                }
+
+                void relation(const osmium::Relation& relation) {
+                    if (m_options.use_change_ops) {
+                        open_close_op_tag(relation.visible() ? (relation.version() == 1 ? operation::op_create : operation::op_modify) : operation::op_delete);
+                    }
+
+                    write_prefix();
+                    *m_out += "<relation";
+                    write_meta(relation);
+
+                    if (relation.tags().empty() && relation.members().empty()) {
+                        *m_out += "/>\n";
+                        return;
+                    }
+
+                    *m_out += ">\n";
+
+                    for (const auto& member : relation.members()) {
+                        write_prefix();
+                        *m_out += "  <member type=\"";
+                        *m_out += item_type_to_name(member.type());
+                        output_formatted("\" ref=\"%" PRId64 "\" role=\"", member.ref());
+                        append_xml_encoded_string(*m_out, member.role());
+                        *m_out += "\"/>\n";
+                    }
+
+                    write_tags(relation.tags(), prefix_spaces());
+
+                    write_prefix();
+                    *m_out += "</relation>\n";
+                }
+
+                void changeset(const osmium::Changeset& changeset) {
+                    *m_out += " <changeset";
+
+                    output_formatted(" id=\"%" PRId32 "\"", changeset.id());
+
+                    if (changeset.created_at()) {
+                        *m_out += " created_at=\"";
+                        *m_out += changeset.created_at().to_iso();
+                        *m_out += "\"";
+                    }
+
+                    if (changeset.closed_at()) {
+                        *m_out += " closed_at=\"";
+                        *m_out += changeset.closed_at().to_iso();
+                        *m_out += "\" open=\"false\"";
+                    } else {
+                        *m_out += " open=\"true\"";
+                    }
+
+                    if (!changeset.user_is_anonymous()) {
+                        *m_out += " user=\"";
+                        append_xml_encoded_string(*m_out, changeset.user());
+                        output_formatted("\" uid=\"%d\"", changeset.uid());
+                    }
+
+                    if (changeset.bounds()) {
+                        output_formatted(" min_lat=\"%.7f\"", changeset.bounds().bottom_left().lat_without_check());
+                        output_formatted(" min_lon=\"%.7f\"", changeset.bounds().bottom_left().lon_without_check());
+                        output_formatted(" max_lat=\"%.7f\"", changeset.bounds().top_right().lat_without_check());
+                        output_formatted(" max_lon=\"%.7f\"", changeset.bounds().top_right().lon_without_check());
+                    }
+
+                    output_formatted(" num_changes=\"%" PRId32 "\"", changeset.num_changes());
+                    output_formatted(" comments_count=\"%" PRId32 "\"", changeset.num_comments());
+
+                    // If there are no tags and no comments, we can close the
+                    // tag right here and are done.
+                    if (changeset.tags().empty() && changeset.num_comments() == 0) {
+                        *m_out += "/>\n";
+                        return;
+                    }
+
+                    *m_out += ">\n";
+
+                    write_tags(changeset.tags(), 0);
+
+                    if (changeset.num_comments() > 0) {
+                        *m_out += "  <discussion>\n";
+                        write_discussion(changeset.discussion());
+                    }
+
+                    *m_out += " </changeset>\n";
+                }
+
+            }; // class XMLOutputBlock
+
+            class XMLOutputFormat : public osmium::io::detail::OutputFormat, public osmium::handler::Handler {
+
+                xml_output_options m_options;
+
+            public:
+
+                XMLOutputFormat(const osmium::io::File& file, future_string_queue_type& output_queue) :
+                    OutputFormat(output_queue),
+                    m_options() {
+                    m_options.add_metadata     = file.is_not_false("add_metadata");
+                    m_options.use_change_ops   = file.is_true("xml_change_format");
+                    m_options.add_visible_flag = (file.has_multiple_object_versions() || file.is_true("force_visible_flag")) && !m_options.use_change_ops;
+                }
+
+                XMLOutputFormat(const XMLOutputFormat&) = delete;
+                XMLOutputFormat& operator=(const XMLOutputFormat&) = delete;
+
+                ~XMLOutputFormat() noexcept final = default;
+
+                void write_header(const osmium::io::Header& header) final {
+                    std::string out = "<?xml version='1.0' encoding='UTF-8'?>\n";
+
+                    if (m_options.use_change_ops) {
+                        out += "<osmChange version=\"0.6\" generator=\"";
+                    } else {
+                        out += "<osm version=\"0.6\"";
+
+                        std::string xml_josm_upload = header.get("xml_josm_upload");
+                        if (xml_josm_upload == "true" || xml_josm_upload == "false") {
+                            out += " upload=\"";
+                            out += xml_josm_upload;
+                            out += "\"";
+                        }
+                        out += " generator=\"";
+                    }
+                    append_xml_encoded_string(out, header.get("generator").c_str());
+                    out += "\">\n";
+
+                    for (const auto& box : header.boxes()) {
+                        out += "  <bounds";
+                        append_printf_formatted_string(out, " minlon=\"%.7f\"", box.bottom_left().lon());
+                        append_printf_formatted_string(out, " minlat=\"%.7f\"", box.bottom_left().lat());
+                        append_printf_formatted_string(out, " maxlon=\"%.7f\"", box.top_right().lon());
+                        append_printf_formatted_string(out, " maxlat=\"%.7f\"/>\n", box.top_right().lat());
+                    }
+
+                    send_to_output_queue(std::move(out));
+                }
+
+                void write_buffer(osmium::memory::Buffer&& buffer) final {
+                    m_output_queue.push(osmium::thread::Pool::instance().submit(XMLOutputBlock{std::move(buffer), m_options}));
+                }
+
+                void write_end() final {
+                    std::string out;
+
+                    if (m_options.use_change_ops) {
+                        out += "</osmChange>\n";
+                    } else {
+                        out += "</osm>\n";
+                    }
+
+                    send_to_output_queue(std::move(out));
+                }
+
+            }; // class XMLOutputFormat
+
+            // we want the register_output_format() function to run, setting
+            // the variable is only a side-effect, it will never be used
+            const bool registered_xml_output = osmium::io::detail::OutputFormatFactory::instance().register_output_format(osmium::io::file_format::xml,
+                [](const osmium::io::File& file, future_string_queue_type& output_queue) {
+                    return new osmium::io::detail::XMLOutputFormat(file, output_queue);
+            });
+
+            // dummy function to silence the unused variable warning from above
+            inline bool get_registered_xml_output() noexcept {
+                return registered_xml_output;
+            }
+
+        } // namespace detail
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_DETAIL_XML_OUTPUT_FORMAT_HPP

third_party/libosmium/include/osmium/io/detail/zlib.hpp

@@ -0,0 +1,115 @@
+#ifndef OSMIUM_IO_DETAIL_ZLIB_HPP
+#define OSMIUM_IO_DETAIL_ZLIB_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <memory>
+#include <stdexcept>
+#include <string>
+
+#include <zlib.h>
+
+#include <osmium/io/error.hpp>
+#include <osmium/util/cast.hpp>
+
+namespace osmium {
+
+    namespace io {
+
+        namespace detail {
+
+            /**
+             * Compress data using zlib.
+             *
+             * Note that this function can not compress data larger than
+             * what fits in an unsigned long, on Windows this is usually 32bit.
+             *
+             * @param input Data to compress.
+             * @returns Compressed data.
+             */
+            inline std::string zlib_compress(const std::string& input) {
+                unsigned long output_size = ::compressBound(osmium::static_cast_with_assert<unsigned long>(input.size()));
+
+                std::string output(output_size, '\0');
+
+                auto result = ::compress(
+                    reinterpret_cast<unsigned char*>(const_cast<char *>(output.data())),
+                    &output_size,
+                    reinterpret_cast<const unsigned char*>(input.data()),
+                    osmium::static_cast_with_assert<unsigned long>(input.size())
+                );
+
+                if (result != Z_OK) {
+                    throw io_error(std::string("failed to compress data: ") + zError(result));
+                }
+
+                output.resize(output_size);
+
+                return output;
+            }
+
+            /**
+             * Uncompress data using zlib.
+             *
+             * Note that this function can not uncompress data larger than
+             * what fits in an unsigned long, on Windows this is usually 32bit.
+             *
+             * @param input Compressed input data.
+             * @param raw_size Size of uncompressed data.
+             * @param output Uncompressed result data.
+             * @returns Pointer and size to incompressed data.
+             */
+            inline std::pair<const char*, size_t> zlib_uncompress_string(const char* input, unsigned long input_size, unsigned long raw_size, std::string& output) {
+                output.resize(raw_size);
+
+                auto result = ::uncompress(
+                    reinterpret_cast<unsigned char*>(&*output.begin()),
+                    &raw_size,
+                    reinterpret_cast<const unsigned char*>(input),
+                    input_size
+                );
+
+                if (result != Z_OK) {
+                    throw io_error(std::string("failed to uncompress data: ") + zError(result));
+                }
+
+                return std::make_pair(output.data(), output.size());
+            }
+
+        } // namespace detail
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_DETAIL_ZLIB_HPP

third_party/libosmium/include/osmium/io/error.hpp

@@ -0,0 +1,70 @@
+#ifndef OSMIUM_IO_ERROR_HPP
+#define OSMIUM_IO_ERROR_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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>
+#include <string>
+
+namespace osmium {
+
+    /**
+     * Exception thrown when some kind of input/output operation failed.
+     */
+    struct io_error : public std::runtime_error {
+
+        explicit io_error(const std::string& what) :
+            std::runtime_error(what) {
+        }
+
+        explicit io_error(const char* what) :
+            std::runtime_error(what) {
+        }
+
+    }; // struct io_error
+
+    struct unsupported_file_format_error : public io_error {
+
+        explicit unsupported_file_format_error(const std::string& what) :
+            io_error(what) {
+        }
+
+        explicit unsupported_file_format_error(const char* what) :
+            io_error(what) {
+        }
+
+    }; // struct unsupported_file_format_error
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_ERROR_HPP

third_party/libosmium/include/osmium/io/file.hpp

@@ -0,0 +1,328 @@
+#ifndef OSMIUM_IO_FILE_HPP
+#define OSMIUM_IO_FILE_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <cstddef>
+#include <stdexcept>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include <osmium/io/error.hpp>
+#include <osmium/io/file_format.hpp>
+#include <osmium/io/file_compression.hpp>
+#include <osmium/util/options.hpp>
+#include <osmium/util/compatibility.hpp>
+
+namespace osmium {
+
+    /**
+     * @brief Everything related to input and output of OSM data.
+     */
+    namespace io {
+
+        namespace detail {
+
+            inline std::vector<std::string> split(const std::string& in, const char delim) {
+                std::vector<std::string> result;
+                std::stringstream ss(in);
+                std::string item;
+                while (std::getline(ss, item, delim)) {
+                    result.push_back(item);
+                }
+                return result;
+            }
+
+        } // namespace detail
+
+        /**
+         * This class describes an OSM file in one of several different formats.
+         *
+         * If the filename is empty or "-", this means stdin or stdout is used.
+         */
+        class File : public osmium::util::Options {
+
+        private:
+
+            std::string m_filename;
+
+            const char* m_buffer;
+            size_t m_buffer_size;
+
+            std::string m_format_string;
+
+            file_format m_file_format {file_format::unknown};
+
+            file_compression m_file_compression {file_compression::none};
+
+            bool m_has_multiple_object_versions {false};
+
+        public:
+
+            /**
+             * Create File using type and encoding from filename or given
+             * format specification.
+             *
+             * @param filename Filename including suffix. The type and encoding
+             *                 of the file will be taken from the suffix.
+             *                 An empty filename or "-" means stdin or stdout.
+             * @param format File format as string. See the description of the
+             *               parse_format() function for details. If this is
+             *               empty the format will be deduced from the suffix
+             *               of the filename.
+             */
+            explicit File(const std::string& filename = "", const std::string& format = "") :
+                Options(),
+                m_filename(filename),
+                m_buffer(nullptr),
+                m_buffer_size(0),
+                m_format_string(format) {
+
+                // stdin/stdout
+                if (m_filename == "-") {
+                    m_filename = "";
+                }
+
+                // if filename is a URL, default to XML format
+                std::string protocol = m_filename.substr(0, m_filename.find_first_of(':'));
+                if (protocol == "http" || protocol == "https") {
+                    m_file_format = file_format::xml;
+                }
+
+                if (format.empty()) {
+                    detect_format_from_suffix(m_filename);
+                } else {
+                    parse_format(format);
+                }
+            }
+
+            /**
+             * Create File using buffer pointer and size and type and encoding
+             * from given format specification.
+             *
+             * @param buffer Pointer to buffer with data.
+             * @param size   Size of buffer.
+             * @param format File format as string. See the description of the
+             *               parse_format() function for details.
+             */
+            explicit File(const char* buffer, size_t size, const std::string& format = "") :
+                Options(),
+                m_filename(),
+                m_buffer(buffer),
+                m_buffer_size(size),
+                m_format_string(format) {
+                if (format != "") {
+                    parse_format(format);
+                }
+            }
+
+            File(const File&) = default;
+            File& operator=(const File&) = default;
+
+            File(File&&) = default;
+            File& operator=(File&&) = default;
+
+            ~File() = default;
+
+            const char* buffer() const noexcept {
+                return m_buffer;
+            }
+
+            size_t buffer_size() const noexcept {
+                return m_buffer_size;
+            }
+
+            void parse_format(const std::string& format) {
+                std::vector<std::string> options = detail::split(format, ',');
+
+                // if the first item in the format list doesn't contain
+                // an equals sign, it is a format
+                if (!options.empty() && options[0].find_first_of('=') == std::string::npos) {
+                    detect_format_from_suffix(options[0]);
+                    options.erase(options.begin());
+                }
+
+                for (auto& option : options) {
+                    size_t pos = option.find_first_of('=');
+                    if (pos == std::string::npos) {
+                        set(option, true);
+                    } else {
+                        std::string value = option.substr(pos+1);
+                        option.erase(pos);
+                        set(option, value);
+                    }
+                }
+
+                if (get("history") == "true") {
+                    m_has_multiple_object_versions = true;
+                } else if (get("history") == "false") {
+                    m_has_multiple_object_versions = false;
+                }
+            }
+
+            void detect_format_from_suffix(const std::string& name) {
+                std::vector<std::string> suffixes = detail::split(name, '.');
+
+                if (suffixes.empty()) return;
+
+                // if the last suffix is one of a known set of compressions,
+                // set that compression
+                if (suffixes.back() == "gz") {
+                    m_file_compression = file_compression::gzip;
+                    suffixes.pop_back();
+                } else if (suffixes.back() == "bz2") {
+                    m_file_compression = file_compression::bzip2;
+                    suffixes.pop_back();
+                }
+
+                if (suffixes.empty()) return;
+
+                // if the last suffix is one of a known set of formats,
+                // set that format
+                if (suffixes.back() == "pbf") {
+                    m_file_format = file_format::pbf;
+                    suffixes.pop_back();
+                } else if (suffixes.back() == "xml") {
+                    m_file_format = file_format::xml;
+                    suffixes.pop_back();
+                } else if (suffixes.back() == "opl") {
+                    m_file_format = file_format::opl;
+                    suffixes.pop_back();
+                } else if (suffixes.back() == "json") {
+                    m_file_format = file_format::json;
+                    suffixes.pop_back();
+                } else if (suffixes.back() == "o5m") {
+                    m_file_format = file_format::o5m;
+                    suffixes.pop_back();
+                } else if (suffixes.back() == "o5c") {
+                    m_file_format = file_format::o5m;
+                    m_has_multiple_object_versions = true;
+                    set("o5c_change_format", true);
+                    suffixes.pop_back();
+                } else if (suffixes.back() == "debug") {
+                    m_file_format = file_format::debug;
+                    suffixes.pop_back();
+                }
+
+                if (suffixes.empty()) return;
+
+                if (suffixes.back() == "osm") {
+                    if (m_file_format == file_format::unknown) m_file_format = file_format::xml;
+                    suffixes.pop_back();
+                } else if (suffixes.back() == "osh") {
+                    if (m_file_format == file_format::unknown) m_file_format = file_format::xml;
+                    m_has_multiple_object_versions = true;
+                    suffixes.pop_back();
+                } else if (suffixes.back() == "osc") {
+                    if (m_file_format == file_format::unknown) m_file_format = file_format::xml;
+                    m_has_multiple_object_versions = true;
+                    set("xml_change_format", true);
+                    suffixes.pop_back();
+                }
+            }
+
+            /**
+             * Check file format etc. for consistency and throw exception if
+             * there is a problem.
+             *
+             * @throws osmium::io_error
+             */
+            const File& check() const {
+                if (m_file_format == file_format::unknown) {
+                    std::string msg = "Could not detect file format";
+                    if (!m_format_string.empty())  {
+                        msg += " from format string '";
+                        msg += m_format_string;
+                        msg += "'";
+                    }
+                    if (m_filename.empty()) {
+                        msg += " for stdin/stdout";
+                    } else {
+                        msg += " for filename '";
+                        msg += m_filename;
+                        msg += "'";
+                    }
+                    msg += ".";
+                    throw io_error(msg);
+                }
+                return *this;
+            }
+
+            file_format format() const noexcept {
+                return m_file_format;
+            }
+
+            File& set_format(file_format format) noexcept {
+                m_file_format = format;
+                return *this;
+            }
+
+            file_compression compression() const noexcept {
+                return m_file_compression;
+            }
+
+            File& set_compression(file_compression compression) noexcept {
+                m_file_compression = compression;
+                return *this;
+            }
+
+            bool has_multiple_object_versions() const noexcept {
+                return m_has_multiple_object_versions;
+            }
+
+            File& set_has_multiple_object_versions(bool value) noexcept {
+                m_has_multiple_object_versions = value;
+                return *this;
+            }
+
+            File& filename(const std::string& filename) {
+                if (filename == "-") {
+                    m_filename = "";
+                } else {
+                    m_filename = filename;
+                }
+                return *this;
+            }
+
+            const std::string& filename() const noexcept {
+                return m_filename;
+            }
+
+        }; // class File
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_FILE_HPP

third_party/libosmium/include/osmium/io/file_compression.hpp

@@ -0,0 +1,72 @@
+#ifndef OSMIUM_IO_FILE_COMPRESSION_HPP
+#define OSMIUM_IO_FILE_COMPRESSION_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <iosfwd>
+
+namespace osmium {
+
+    namespace io {
+
+        enum class file_compression {
+            none  = 0,
+            gzip  = 1,
+            bzip2 = 2
+        };
+
+// avoid g++ false positive
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wreturn-type"
+        inline const char* as_string(file_compression compression) {
+            switch (compression) {
+                case file_compression::none:
+                    return "none";
+                case file_compression::gzip:
+                    return "gzip";
+                case file_compression::bzip2:
+                    return "bzip2";
+            }
+        }
+#pragma GCC diagnostic pop
+
+        template <typename TChar, typename TTraits>
+        inline std::basic_ostream<TChar, TTraits>& operator<<(std::basic_ostream<TChar, TTraits>& out, const file_compression compression) {
+            return out << as_string(compression);
+        }
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_FILE_COMPRESSION_HPP

third_party/libosmium/include/osmium/io/file_format.hpp

@@ -0,0 +1,84 @@
+#ifndef OSMIUM_IO_FILE_FORMAT_HPP
+#define OSMIUM_IO_FILE_FORMAT_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <iosfwd>
+
+namespace osmium {
+
+    namespace io {
+
+        enum class file_format {
+            unknown = 0,
+            xml     = 1,
+            pbf     = 2,
+            opl     = 3,
+            json    = 4,
+            o5m     = 5,
+            debug   = 6
+        };
+
+// avoid g++ false positive
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wreturn-type"
+        inline const char* as_string(file_format format) {
+            switch (format) {
+                case file_format::unknown:
+                    return "unknown";
+                case file_format::xml:
+                    return "XML";
+                case file_format::pbf:
+                    return "PBF";
+                case file_format::opl:
+                    return "OPL";
+                case file_format::json:
+                    return "JSON";
+                case file_format::o5m:
+                    return "O5M";
+                case file_format::debug:
+                    return "DEBUG";
+            }
+        }
+#pragma GCC diagnostic pop
+
+        template <typename TChar, typename TTraits>
+        inline std::basic_ostream<TChar, TTraits>& operator<<(std::basic_ostream<TChar, TTraits>& out, const file_format format) {
+            return out << as_string(format);
+        }
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_FILE_FORMAT_HPP

third_party/libosmium/include/osmium/io/gzip_compression.hpp

@@ -0,0 +1,277 @@
+#ifndef OSMIUM_IO_GZIP_COMPRESSION_HPP
+#define OSMIUM_IO_GZIP_COMPRESSION_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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.
+
+*/
+
+/**
+ * @file
+ *
+ * Include this file if you want to read or write gzip-compressed OSM XML
+ * files.
+ *
+ * @attention If you include this file, you'll need to link with `libz`.
+ */
+
+#include <stdexcept>
+#include <string>
+
+#include <errno.h>
+#include <zlib.h>
+
+#include <osmium/io/compression.hpp>
+#include <osmium/io/error.hpp>
+#include <osmium/io/file_compression.hpp>
+#include <osmium/io/writer_options.hpp>
+#include <osmium/util/cast.hpp>
+#include <osmium/util/compatibility.hpp>
+
+namespace osmium {
+
+    /**
+     * Exception thrown when there are problems compressing or
+     * decompressing gzip files.
+     */
+    struct gzip_error : public io_error {
+
+        int gzip_error_code;
+        int system_errno;
+
+        gzip_error(const std::string& what, int error_code) :
+            io_error(what),
+            gzip_error_code(error_code),
+            system_errno(error_code == Z_ERRNO ? errno : 0) {
+        }
+
+    }; // struct gzip_error
+
+    namespace io {
+
+        namespace detail {
+
+            OSMIUM_NORETURN inline void throw_gzip_error(gzFile gzfile, const char* msg, int zlib_error = 0) {
+                std::string error("gzip error: ");
+                error += msg;
+                error += ": ";
+                int errnum = zlib_error;
+                if (zlib_error) {
+                    error += std::to_string(zlib_error);
+                } else {
+                    error += ::gzerror(gzfile, &errnum);
+                }
+                throw osmium::gzip_error(error, errnum);
+            }
+
+        } // namespace detail
+
+        class GzipCompressor : public Compressor {
+
+            int m_fd;
+            gzFile m_gzfile;
+
+        public:
+
+            explicit GzipCompressor(int fd, fsync sync) :
+                Compressor(sync),
+                m_fd(dup(fd)),
+                m_gzfile(::gzdopen(fd, "w")) {
+                if (!m_gzfile) {
+                    detail::throw_gzip_error(m_gzfile, "write initialization failed");
+                }
+            }
+
+            ~GzipCompressor() noexcept final {
+                try {
+                    close();
+                } catch (...) {
+                    // Ignore any exceptions because destructor must not throw.
+                }
+            }
+
+            void write(const std::string& data) final {
+                if (!data.empty()) {
+                    int nwrite = ::gzwrite(m_gzfile, data.data(), static_cast_with_assert<unsigned int>(data.size()));
+                    if (nwrite == 0) {
+                        detail::throw_gzip_error(m_gzfile, "write failed");
+                    }
+                }
+            }
+
+            void close() final {
+                if (m_gzfile) {
+                    int result = ::gzclose(m_gzfile);
+                    m_gzfile = nullptr;
+                    if (result != Z_OK) {
+                        detail::throw_gzip_error(m_gzfile, "write close failed", result);
+                    }
+                    if (do_fsync()) {
+                        osmium::io::detail::reliable_fsync(m_fd);
+                    }
+                    osmium::io::detail::reliable_close(m_fd);
+                }
+            }
+
+        }; // class GzipCompressor
+
+        class GzipDecompressor : public Decompressor {
+
+            gzFile m_gzfile;
+
+        public:
+
+            explicit GzipDecompressor(int fd) :
+                Decompressor(),
+                m_gzfile(::gzdopen(fd, "r")) {
+                if (!m_gzfile) {
+                    detail::throw_gzip_error(m_gzfile, "read initialization failed");
+                }
+            }
+
+            ~GzipDecompressor() noexcept final {
+                try {
+                    close();
+                } catch (...) {
+                    // Ignore any exceptions because destructor must not throw.
+                }
+            }
+
+            std::string read() final {
+                std::string buffer(osmium::io::Decompressor::input_buffer_size, '\0');
+                int nread = ::gzread(m_gzfile, const_cast<char*>(buffer.data()), static_cast_with_assert<unsigned int>(buffer.size()));
+                if (nread < 0) {
+                    detail::throw_gzip_error(m_gzfile, "read failed");
+                }
+                buffer.resize(static_cast<std::string::size_type>(nread));
+                return buffer;
+            }
+
+            void close() final {
+                if (m_gzfile) {
+                    int result = ::gzclose(m_gzfile);
+                    m_gzfile = nullptr;
+                    if (result != Z_OK) {
+                        detail::throw_gzip_error(m_gzfile, "read close failed", result);
+                    }
+                }
+            }
+
+        }; // class GzipDecompressor
+
+        class GzipBufferDecompressor : public Decompressor {
+
+            const char* m_buffer;
+            size_t m_buffer_size;
+            z_stream m_zstream;
+
+        public:
+
+            GzipBufferDecompressor(const char* buffer, size_t size) :
+                m_buffer(buffer),
+                m_buffer_size(size),
+                m_zstream() {
+                m_zstream.next_in = reinterpret_cast<unsigned char*>(const_cast<char*>(buffer));
+                m_zstream.avail_in = static_cast_with_assert<unsigned int>(size);
+                int result = inflateInit2(&m_zstream, MAX_WBITS | 32);
+                if (result != Z_OK) {
+                    std::string message("gzip error: decompression init failed: ");
+                    if (m_zstream.msg) {
+                        message.append(m_zstream.msg);
+                    }
+                    throw osmium::gzip_error(message, result);
+                }
+            }
+
+            ~GzipBufferDecompressor() noexcept final {
+                try {
+                    close();
+                } catch (...) {
+                    // Ignore any exceptions because destructor must not throw.
+                }
+            }
+
+            std::string read() final {
+                std::string output;
+
+                if (m_buffer) {
+                    const size_t buffer_size = 10240;
+                    output.append(buffer_size, '\0');
+                    m_zstream.next_out = reinterpret_cast<unsigned char*>(const_cast<char*>(output.data()));
+                    m_zstream.avail_out = buffer_size;
+                    int result = inflate(&m_zstream, Z_SYNC_FLUSH);
+
+                    if (result != Z_OK) {
+                        m_buffer = nullptr;
+                        m_buffer_size = 0;
+                    }
+
+                    if (result != Z_OK && result != Z_STREAM_END) {
+                        std::string message("gzip error: inflate failed: ");
+                        if (m_zstream.msg) {
+                            message.append(m_zstream.msg);
+                        }
+                        throw osmium::gzip_error(message, result);
+                    }
+
+                    output.resize(static_cast<unsigned long>(m_zstream.next_out - reinterpret_cast<const unsigned char*>(output.data())));
+                }
+
+                return output;
+            }
+
+            void close() final {
+                inflateEnd(&m_zstream);
+            }
+
+        }; // class GzipBufferDecompressor
+
+        namespace detail {
+
+            // we want the register_compression() function to run, setting
+            // the variable is only a side-effect, it will never be used
+            const bool registered_gzip_compression = osmium::io::CompressionFactory::instance().register_compression(osmium::io::file_compression::gzip,
+                [](int fd, fsync sync) { return new osmium::io::GzipCompressor(fd, sync); },
+                [](int fd) { return new osmium::io::GzipDecompressor(fd); },
+                [](const char* buffer, size_t size) { return new osmium::io::GzipBufferDecompressor(buffer, size); }
+            );
+
+            // dummy function to silence the unused variable warning from above
+            inline bool get_registered_gzip_compression() noexcept {
+                return registered_gzip_compression;
+            }
+
+        } // namespace detail
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_GZIP_COMPRESSION_HPP

third_party/libosmium/include/osmium/io/header.hpp

@@ -0,0 +1,122 @@
+#ifndef OSMIUM_IO_HEADER_HPP
+#define OSMIUM_IO_HEADER_HPP
+
+/*
+
+This file is part of Osmium (http://osmcode.org/libosmium).
+
+Copyright 2013-2016 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 <initializer_list>
+#include <vector>
+
+#include <osmium/osm/box.hpp>
+#include <osmium/util/options.hpp>
+
+namespace osmium {
+
+    namespace io {
+
+        /**
+        * Meta information from the header of an OSM file.
+        */
+        class Header : public osmium::util::Options {
+
+            /// Bounding boxes
+            std::vector<osmium::Box> m_boxes;
+
+            /**
+            * Are there possibly multiple versions of the same object in this stream of objects?
+            * This is true for history files and for change files, but not for normal OSM files.
+            */
+            bool m_has_multiple_object_versions = false;
+
+        public:
+
+            Header() = default;
+
+            explicit Header(const std::initializer_list<osmium::util::Options::value_type>& values) :
+                Options(values) {
+            }
+
+            Header(const Header&) = default;
+            Header& operator=(const Header&) = default;
+
+            Header(Header&&) = default;
+            Header& operator=(Header&&) = default;
+
+            ~Header() = default;
+
+            std::vector<osmium::Box>& boxes() noexcept {
+                return m_boxes;
+            }
+
+            const std::vector<osmium::Box>& boxes() const noexcept {
+                return m_boxes;
+            }
+
+            Header& boxes(const std::vector<osmium::Box>& boxes) noexcept {
+                m_boxes = boxes;
+                return *this;
+            }
+
+            osmium::Box box() const {
+                return m_boxes.empty() ? osmium::Box() : m_boxes.front();
+            }
+
+            osmium::Box joined_boxes() const {
+                osmium::Box box;
+                for (const auto& b : m_boxes) {
+                    box.extend(b.bottom_left());
+                    box.extend(b.top_right());
+                }
+                return box;
+            }
+
+            Header& add_box(const osmium::Box& box) {
+                m_boxes.push_back(box);
+                return *this;
+            }
+
+            bool has_multiple_object_versions() const noexcept {
+                return m_has_multiple_object_versions;
+            }
+
+            Header& set_has_multiple_object_versions(bool value) noexcept {
+                m_has_multiple_object_versions = value;
+                return *this;
+            }
+
+        }; // class Header
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_HEADER_HPP