From 73fb59697382e3abb37f55c9c1a274efb00b0e45 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Tue, 26 Aug 2014 16:03:44 +0200 Subject: [PATCH 01/80] add libosmium --- ThirdParty/osmium/area/assembler.hpp | 767 ++++++++++++++ .../osmium/area/detail/node_ref_segment.hpp | 257 +++++ ThirdParty/osmium/area/detail/proto_ring.hpp | 274 +++++ .../osmium/area/detail/segment_list.hpp | 216 ++++ .../osmium/area/multipolygon_collector.hpp | 211 ++++ ThirdParty/osmium/area/problem_reporter.hpp | 149 +++ .../area/problem_reporter_exception.hpp | 96 ++ .../osmium/area/problem_reporter_ogr.hpp | 202 ++++ .../osmium/area/problem_reporter_stream.hpp | 96 ++ ThirdParty/osmium/builder/builder.hpp | 179 ++++ ThirdParty/osmium/builder/builder_helper.hpp | 103 ++ .../osmium/builder/osm_object_builder.hpp | 207 ++++ ThirdParty/osmium/config/constexpr.hpp | 43 + ThirdParty/osmium/diff_handler.hpp | 67 ++ ThirdParty/osmium/diff_iterator.hpp | 129 +++ ThirdParty/osmium/diff_visitor.hpp | 104 ++ ThirdParty/osmium/dynamic_handler.hpp | 195 ++++ ThirdParty/osmium/geom/coordinates.hpp | 106 ++ ThirdParty/osmium/geom/factory.hpp | 282 ++++++ ThirdParty/osmium/geom/geojson.hpp | 149 +++ ThirdParty/osmium/geom/geos.hpp | 224 +++++ ThirdParty/osmium/geom/haversine.hpp | 96 ++ .../osmium/geom/mercator_projection.hpp | 109 ++ ThirdParty/osmium/geom/ogr.hpp | 157 +++ ThirdParty/osmium/geom/projection.hpp | 159 +++ ThirdParty/osmium/geom/relations.hpp | 57 ++ ThirdParty/osmium/geom/util.hpp | 71 ++ ThirdParty/osmium/geom/wkb.hpp | 264 +++++ ThirdParty/osmium/geom/wkt.hpp | 142 +++ ThirdParty/osmium/handler.hpp | 101 ++ ThirdParty/osmium/handler/chain.hpp | 128 +++ ThirdParty/osmium/handler/disk_store.hpp | 111 ++ ThirdParty/osmium/handler/dump.hpp | 294 ++++++ .../handler/node_locations_for_ways.hpp | 148 +++ .../osmium/handler/object_relations.hpp | 106 ++ .../osmium/index/detail/mmap_vector_anon.hpp | 78 ++ .../osmium/index/detail/mmap_vector_base.hpp | 183 ++++ .../osmium/index/detail/mmap_vector_file.hpp | 83 ++ ThirdParty/osmium/index/detail/tmpfile.hpp | 62 ++ ThirdParty/osmium/index/detail/typed_mmap.hpp | 227 +++++ ThirdParty/osmium/index/index.hpp | 100 ++ ThirdParty/osmium/index/map.hpp | 156 +++ ThirdParty/osmium/index/map/dummy.hpp | 87 ++ .../osmium/index/map/mmap_vector_anon.hpp | 61 ++ .../osmium/index/map/mmap_vector_file.hpp | 57 ++ ThirdParty/osmium/index/map/sparse_table.hpp | 140 +++ ThirdParty/osmium/index/map/stl_map.hpp | 112 +++ ThirdParty/osmium/index/map/stl_vector.hpp | 61 ++ ThirdParty/osmium/index/map/vector.hpp | 208 ++++ ThirdParty/osmium/index/multimap.hpp | 125 +++ ThirdParty/osmium/index/multimap/hybrid.hpp | 199 ++++ .../index/multimap/mmap_vector_anon.hpp | 58 ++ .../index/multimap/mmap_vector_file.hpp | 54 + .../osmium/index/multimap/stl_multimap.hpp | 151 +++ .../osmium/index/multimap/stl_vector.hpp | 58 ++ ThirdParty/osmium/index/multimap/vector.hpp | 141 +++ ThirdParty/osmium/io/any_compression.hpp | 39 + ThirdParty/osmium/io/any_input.hpp | 41 + ThirdParty/osmium/io/any_output.hpp | 42 + ThirdParty/osmium/io/bzip2_compression.hpp | 196 ++++ ThirdParty/osmium/io/compression.hpp | 240 +++++ ThirdParty/osmium/io/detail/input_format.hpp | 160 +++ .../osmium/io/detail/opl_output_format.hpp | 303 ++++++ ThirdParty/osmium/io/detail/output_format.hpp | 156 +++ ThirdParty/osmium/io/detail/pbf.hpp | 79 ++ .../osmium/io/detail/pbf_input_format.hpp | 681 +++++++++++++ .../osmium/io/detail/pbf_output_format.hpp | 950 ++++++++++++++++++ .../osmium/io/detail/pbf_stringtable.hpp | 196 ++++ ThirdParty/osmium/io/detail/read_thread.hpp | 105 ++ ThirdParty/osmium/io/detail/read_write.hpp | 170 ++++ ThirdParty/osmium/io/detail/write_thread.hpp | 86 ++ .../osmium/io/detail/xml_input_format.hpp | 677 +++++++++++++ .../osmium/io/detail/xml_output_format.hpp | 482 +++++++++ ThirdParty/osmium/io/detail/zlib.hpp | 98 ++ ThirdParty/osmium/io/file.hpp | 319 ++++++ ThirdParty/osmium/io/file_compression.hpp | 68 ++ ThirdParty/osmium/io/file_format.hpp | 74 ++ ThirdParty/osmium/io/gzip_compression.hpp | 132 +++ ThirdParty/osmium/io/header.hpp | 122 +++ ThirdParty/osmium/io/input_iterator.hpp | 139 +++ ThirdParty/osmium/io/opl_output.hpp | 39 + ThirdParty/osmium/io/output_iterator.hpp | 114 +++ ThirdParty/osmium/io/overwrite.hpp | 52 + ThirdParty/osmium/io/pbf_input.hpp | 39 + ThirdParty/osmium/io/pbf_output.hpp | 39 + ThirdParty/osmium/io/reader.hpp | 281 ++++++ ThirdParty/osmium/io/reader_iterator.hpp | 51 + ThirdParty/osmium/io/writer.hpp | 142 +++ ThirdParty/osmium/io/xml_input.hpp | 39 + ThirdParty/osmium/io/xml_output.hpp | 39 + ThirdParty/osmium/memory/buffer.hpp | 523 ++++++++++ ThirdParty/osmium/memory/collection.hpp | 153 +++ ThirdParty/osmium/memory/item.hpp | 178 ++++ ThirdParty/osmium/memory/item_iterator.hpp | 181 ++++ .../osmium/object_pointer_collection.hpp | 112 +++ ThirdParty/osmium/osm.hpp | 48 + ThirdParty/osmium/osm/area.hpp | 172 ++++ ThirdParty/osmium/osm/box.hpp | 207 ++++ ThirdParty/osmium/osm/changeset.hpp | 340 +++++++ ThirdParty/osmium/osm/diff_object.hpp | 156 +++ ThirdParty/osmium/osm/entity.hpp | 55 + ThirdParty/osmium/osm/entity_bits.hpp | 93 ++ ThirdParty/osmium/osm/item_type.hpp | 163 +++ ThirdParty/osmium/osm/location.hpp | 311 ++++++ ThirdParty/osmium/osm/node.hpp | 80 ++ ThirdParty/osmium/osm/node_ref.hpp | 152 +++ ThirdParty/osmium/osm/node_ref_list.hpp | 135 +++ ThirdParty/osmium/osm/object.hpp | 429 ++++++++ ThirdParty/osmium/osm/object_comparisons.hpp | 110 ++ ThirdParty/osmium/osm/relation.hpp | 189 ++++ ThirdParty/osmium/osm/segment.hpp | 105 ++ ThirdParty/osmium/osm/tag.hpp | 140 +++ ThirdParty/osmium/osm/timestamp.hpp | 159 +++ ThirdParty/osmium/osm/types.hpp | 83 ++ ThirdParty/osmium/osm/undirected_segment.hpp | 100 ++ ThirdParty/osmium/osm/way.hpp | 115 +++ ThirdParty/osmium/relations/collector.hpp | 535 ++++++++++ .../osmium/relations/detail/member_meta.hpp | 131 +++ .../osmium/relations/detail/relation_meta.hpp | 136 +++ ThirdParty/osmium/tags/filter.hpp | 148 +++ ThirdParty/osmium/tags/regex_filter.hpp | 58 ++ ThirdParty/osmium/tags/taglist.hpp | 67 ++ ThirdParty/osmium/thread/checked_task.hpp | 106 ++ ThirdParty/osmium/thread/function_wrapper.hpp | 104 ++ ThirdParty/osmium/thread/name.hpp | 61 ++ ThirdParty/osmium/thread/pool.hpp | 180 ++++ ThirdParty/osmium/thread/queue.hpp | 128 +++ ThirdParty/osmium/thread/sorted_queue.hpp | 159 +++ ThirdParty/osmium/util/compatibility.hpp | 47 + ThirdParty/osmium/util/options.hpp | 155 +++ ThirdParty/osmium/util/verbose_output.hpp | 139 +++ ThirdParty/osmium/visitor.hpp | 255 +++++ 132 files changed, 21688 insertions(+) create mode 100644 ThirdParty/osmium/area/assembler.hpp create mode 100644 ThirdParty/osmium/area/detail/node_ref_segment.hpp create mode 100644 ThirdParty/osmium/area/detail/proto_ring.hpp create mode 100644 ThirdParty/osmium/area/detail/segment_list.hpp create mode 100644 ThirdParty/osmium/area/multipolygon_collector.hpp create mode 100644 ThirdParty/osmium/area/problem_reporter.hpp create mode 100644 ThirdParty/osmium/area/problem_reporter_exception.hpp create mode 100644 ThirdParty/osmium/area/problem_reporter_ogr.hpp create mode 100644 ThirdParty/osmium/area/problem_reporter_stream.hpp create mode 100644 ThirdParty/osmium/builder/builder.hpp create mode 100644 ThirdParty/osmium/builder/builder_helper.hpp create mode 100644 ThirdParty/osmium/builder/osm_object_builder.hpp create mode 100644 ThirdParty/osmium/config/constexpr.hpp create mode 100644 ThirdParty/osmium/diff_handler.hpp create mode 100644 ThirdParty/osmium/diff_iterator.hpp create mode 100644 ThirdParty/osmium/diff_visitor.hpp create mode 100644 ThirdParty/osmium/dynamic_handler.hpp create mode 100644 ThirdParty/osmium/geom/coordinates.hpp create mode 100644 ThirdParty/osmium/geom/factory.hpp create mode 100644 ThirdParty/osmium/geom/geojson.hpp create mode 100644 ThirdParty/osmium/geom/geos.hpp create mode 100644 ThirdParty/osmium/geom/haversine.hpp create mode 100644 ThirdParty/osmium/geom/mercator_projection.hpp create mode 100644 ThirdParty/osmium/geom/ogr.hpp create mode 100644 ThirdParty/osmium/geom/projection.hpp create mode 100644 ThirdParty/osmium/geom/relations.hpp create mode 100644 ThirdParty/osmium/geom/util.hpp create mode 100644 ThirdParty/osmium/geom/wkb.hpp create mode 100644 ThirdParty/osmium/geom/wkt.hpp create mode 100644 ThirdParty/osmium/handler.hpp create mode 100644 ThirdParty/osmium/handler/chain.hpp create mode 100644 ThirdParty/osmium/handler/disk_store.hpp create mode 100644 ThirdParty/osmium/handler/dump.hpp create mode 100644 ThirdParty/osmium/handler/node_locations_for_ways.hpp create mode 100644 ThirdParty/osmium/handler/object_relations.hpp create mode 100644 ThirdParty/osmium/index/detail/mmap_vector_anon.hpp create mode 100644 ThirdParty/osmium/index/detail/mmap_vector_base.hpp create mode 100644 ThirdParty/osmium/index/detail/mmap_vector_file.hpp create mode 100644 ThirdParty/osmium/index/detail/tmpfile.hpp create mode 100644 ThirdParty/osmium/index/detail/typed_mmap.hpp create mode 100644 ThirdParty/osmium/index/index.hpp create mode 100644 ThirdParty/osmium/index/map.hpp create mode 100644 ThirdParty/osmium/index/map/dummy.hpp create mode 100644 ThirdParty/osmium/index/map/mmap_vector_anon.hpp create mode 100644 ThirdParty/osmium/index/map/mmap_vector_file.hpp create mode 100644 ThirdParty/osmium/index/map/sparse_table.hpp create mode 100644 ThirdParty/osmium/index/map/stl_map.hpp create mode 100644 ThirdParty/osmium/index/map/stl_vector.hpp create mode 100644 ThirdParty/osmium/index/map/vector.hpp create mode 100644 ThirdParty/osmium/index/multimap.hpp create mode 100644 ThirdParty/osmium/index/multimap/hybrid.hpp create mode 100644 ThirdParty/osmium/index/multimap/mmap_vector_anon.hpp create mode 100644 ThirdParty/osmium/index/multimap/mmap_vector_file.hpp create mode 100644 ThirdParty/osmium/index/multimap/stl_multimap.hpp create mode 100644 ThirdParty/osmium/index/multimap/stl_vector.hpp create mode 100644 ThirdParty/osmium/index/multimap/vector.hpp create mode 100644 ThirdParty/osmium/io/any_compression.hpp create mode 100644 ThirdParty/osmium/io/any_input.hpp create mode 100644 ThirdParty/osmium/io/any_output.hpp create mode 100644 ThirdParty/osmium/io/bzip2_compression.hpp create mode 100644 ThirdParty/osmium/io/compression.hpp create mode 100644 ThirdParty/osmium/io/detail/input_format.hpp create mode 100644 ThirdParty/osmium/io/detail/opl_output_format.hpp create mode 100644 ThirdParty/osmium/io/detail/output_format.hpp create mode 100644 ThirdParty/osmium/io/detail/pbf.hpp create mode 100644 ThirdParty/osmium/io/detail/pbf_input_format.hpp create mode 100644 ThirdParty/osmium/io/detail/pbf_output_format.hpp create mode 100644 ThirdParty/osmium/io/detail/pbf_stringtable.hpp create mode 100644 ThirdParty/osmium/io/detail/read_thread.hpp create mode 100644 ThirdParty/osmium/io/detail/read_write.hpp create mode 100644 ThirdParty/osmium/io/detail/write_thread.hpp create mode 100644 ThirdParty/osmium/io/detail/xml_input_format.hpp create mode 100644 ThirdParty/osmium/io/detail/xml_output_format.hpp create mode 100644 ThirdParty/osmium/io/detail/zlib.hpp create mode 100644 ThirdParty/osmium/io/file.hpp create mode 100644 ThirdParty/osmium/io/file_compression.hpp create mode 100644 ThirdParty/osmium/io/file_format.hpp create mode 100644 ThirdParty/osmium/io/gzip_compression.hpp create mode 100644 ThirdParty/osmium/io/header.hpp create mode 100644 ThirdParty/osmium/io/input_iterator.hpp create mode 100644 ThirdParty/osmium/io/opl_output.hpp create mode 100644 ThirdParty/osmium/io/output_iterator.hpp create mode 100644 ThirdParty/osmium/io/overwrite.hpp create mode 100644 ThirdParty/osmium/io/pbf_input.hpp create mode 100644 ThirdParty/osmium/io/pbf_output.hpp create mode 100644 ThirdParty/osmium/io/reader.hpp create mode 100644 ThirdParty/osmium/io/reader_iterator.hpp create mode 100644 ThirdParty/osmium/io/writer.hpp create mode 100644 ThirdParty/osmium/io/xml_input.hpp create mode 100644 ThirdParty/osmium/io/xml_output.hpp create mode 100644 ThirdParty/osmium/memory/buffer.hpp create mode 100644 ThirdParty/osmium/memory/collection.hpp create mode 100644 ThirdParty/osmium/memory/item.hpp create mode 100644 ThirdParty/osmium/memory/item_iterator.hpp create mode 100644 ThirdParty/osmium/object_pointer_collection.hpp create mode 100644 ThirdParty/osmium/osm.hpp create mode 100644 ThirdParty/osmium/osm/area.hpp create mode 100644 ThirdParty/osmium/osm/box.hpp create mode 100644 ThirdParty/osmium/osm/changeset.hpp create mode 100644 ThirdParty/osmium/osm/diff_object.hpp create mode 100644 ThirdParty/osmium/osm/entity.hpp create mode 100644 ThirdParty/osmium/osm/entity_bits.hpp create mode 100644 ThirdParty/osmium/osm/item_type.hpp create mode 100644 ThirdParty/osmium/osm/location.hpp create mode 100644 ThirdParty/osmium/osm/node.hpp create mode 100644 ThirdParty/osmium/osm/node_ref.hpp create mode 100644 ThirdParty/osmium/osm/node_ref_list.hpp create mode 100644 ThirdParty/osmium/osm/object.hpp create mode 100644 ThirdParty/osmium/osm/object_comparisons.hpp create mode 100644 ThirdParty/osmium/osm/relation.hpp create mode 100644 ThirdParty/osmium/osm/segment.hpp create mode 100644 ThirdParty/osmium/osm/tag.hpp create mode 100644 ThirdParty/osmium/osm/timestamp.hpp create mode 100644 ThirdParty/osmium/osm/types.hpp create mode 100644 ThirdParty/osmium/osm/undirected_segment.hpp create mode 100644 ThirdParty/osmium/osm/way.hpp create mode 100644 ThirdParty/osmium/relations/collector.hpp create mode 100644 ThirdParty/osmium/relations/detail/member_meta.hpp create mode 100644 ThirdParty/osmium/relations/detail/relation_meta.hpp create mode 100644 ThirdParty/osmium/tags/filter.hpp create mode 100644 ThirdParty/osmium/tags/regex_filter.hpp create mode 100644 ThirdParty/osmium/tags/taglist.hpp create mode 100644 ThirdParty/osmium/thread/checked_task.hpp create mode 100644 ThirdParty/osmium/thread/function_wrapper.hpp create mode 100644 ThirdParty/osmium/thread/name.hpp create mode 100644 ThirdParty/osmium/thread/pool.hpp create mode 100644 ThirdParty/osmium/thread/queue.hpp create mode 100644 ThirdParty/osmium/thread/sorted_queue.hpp create mode 100644 ThirdParty/osmium/util/compatibility.hpp create mode 100644 ThirdParty/osmium/util/options.hpp create mode 100644 ThirdParty/osmium/util/verbose_output.hpp create mode 100644 ThirdParty/osmium/visitor.hpp diff --git a/ThirdParty/osmium/area/assembler.hpp b/ThirdParty/osmium/area/assembler.hpp new file mode 100644 index 000000000..5c8e6c906 --- /dev/null +++ b/ThirdParty/osmium/area/assembler.hpp @@ -0,0 +1,767 @@ +#ifndef OSMIUM_AREA_ASSEMBLER_HPP +#define OSMIUM_AREA_ASSEMBLER_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2014 Jochen Topf 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 +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +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 m_rings; + + std::vector m_outer_rings; + std::vector 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& ways) const { + std::map 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); + } + } + } + + void add_tags_to_area(osmium::builder::AreaBuilder& builder, const osmium::Relation& relation) const { + osmium::tags::KeyFilter filter(true); + filter.add(false, "type").add(false, "created_by").add(false, "source").add(false, "note"); + filter.add(false, "test:id").add(false, "test:section"); + + osmium::tags::KeyFilter::iterator fi_begin(filter, relation.tags().begin(), relation.tags().end()); + osmium::tags::KeyFilter::iterator fi_end(filter, relation.tags().end(), relation.tags().end()); + + auto count = std::distance(fi_begin, fi_end); + + 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 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_segment_front().first().location(), ring.get_segment_back().second().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_segment_back().second(); + + 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_segment_front().first())) { + 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_segment_back().second())) { + 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_segment_front().first(); + + 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_segment_back().second())) { + 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_segment_front().first())) { + 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"; + } + 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"; + } + 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().begin(), ring.segments().end(), segments.begin()); + std::sort(segments.begin(), segments.end()); + 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; + } + auto r1 = std::find_first_of(ring.segments().begin(), ring.segments().end(), it, it+1); + assert(r1 != ring.segments().end()); + 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"; + } + + 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_segment_front().first()); + 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_segment_front().first()); + 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_segment_back().second(), segment.first())) { + combine_rings_back(segment, ring); + return true; + } + if (has_same_location(ring.get_segment_back().second(), segment.second())) { + segment.swap_locations(); + combine_rings_back(segment, ring); + return true; + } + if (has_same_location(ring.get_segment_front().first(), segment.first())) { + segment.swap_locations(); + combine_rings_front(segment, ring); + return true; + } + if (has_same_location(ring.get_segment_front().first(), 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 relation. + { + 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& 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(area_offset).tags(); // tags of the area we just built + + 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(offset); + if (way.is_closed() && way.tags().size() > 0) { + osmium::tags::KeyFilter filter(true); + filter.add(false, "created_by").add(false, "source").add(false, "note"); + filter.add(false, "test:id").add(false, "test:section"); + + osmium::tags::KeyFilter::iterator fi_begin(filter, way.tags().begin(), way.tags().end()); + osmium::tags::KeyFilter::iterator fi_end(filter, way.tags().end(), way.tags().end()); + + auto d = std::distance(fi_begin, fi_end); + if (d > 0) { + 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(fi_begin, fi_end, area_fi_begin) || d != std::distance(area_fi_begin, area_fi_end)) { + Assembler assembler(m_config); + assembler(way, out_buffer); + } + } + } + } + ++memit; + } + } + } + + }; // class Assembler + + } // namespace area + +} // namespace osmium + +#endif // OSMIUM_AREA_ASSEMBLER_HPP diff --git a/ThirdParty/osmium/area/detail/node_ref_segment.hpp b/ThirdParty/osmium/area/detail/node_ref_segment.hpp new file mode 100644 index 000000000..62905d675 --- /dev/null +++ b/ThirdParty/osmium/area/detail/node_ref_segment.hpp @@ -0,0 +1,257 @@ +#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 2014 Jochen Topf 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 +#include +#include +#include +#include + +#include +#include + +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() : + 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 { + return m_first; + } + + /// Return second NodeRef of Segment according to sorting order (bottom left to top right). + const osmium::NodeRef& second() const { + 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 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 { + return !strcmp(m_role, "outer"); + } + + bool role_inner() const { + return !strcmp(m_role, "inner"); + } + + const osmium::Way* way() const { + return m_way; + } + + }; // class NodeRefSegment + + /// NodeRefSegments are equal if both their locations are equal + inline bool operator==(const NodeRefSegment& lhs, const NodeRefSegment& rhs) { + return lhs.first().location() == rhs.first().location() && lhs.second().location() == rhs.second().location(); + } + + inline bool operator!=(const NodeRefSegment& lhs, const NodeRefSegment& rhs) { + 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) { + 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) { + return rhs < lhs; + } + + inline bool operator<=(const NodeRefSegment& lhs, const NodeRefSegment& rhs) { + return ! (rhs < lhs); + } + + inline bool operator>=(const NodeRefSegment& lhs, const NodeRefSegment& rhs) { + return ! (lhs < rhs); + } + + template + inline std::basic_ostream& operator<<(std::basic_ostream& out, const NodeRefSegment& segment) { + return out << segment.first() << "--" << segment.second(); + } + + inline bool outside_x_range(const NodeRefSegment& s1, const NodeRefSegment& s2) { + if (s1.first().location().x() > s2.second().location().x()) { + return true; + } + return false; + } + + inline bool y_range_overlap(const NodeRefSegment& s1, const NodeRefSegment& s2) { + auto m1 = std::minmax(s1.first().location().y(), s1.second().location().y()); + auto 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 to 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. + * + * 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(); + } + + double denom = ((s2.second().lat() - s2.first().lat())*(s1.second().lon() - s1.first().lon())) - + ((s2.second().lon() - s2.first().lon())*(s1.second().lat() - s1.first().lat())); + + if (denom != 0) { + double nume_a = ((s2.second().lon() - s2.first().lon())*(s1.first().lat() - s2.first().lat())) - + ((s2.second().lat() - s2.first().lat())*(s1.first().lon() - s2.first().lon())); + + double nume_b = ((s1.second().lon() - s1.first().lon())*(s1.first().lat() - s2.first().lat())) - + ((s1.second().lat() - s1.first().lat())*(s1.first().lon() - s2.first().lon())); + + if ((denom > 0 && nume_a >= 0 && nume_a <= denom && nume_b >= 0 && nume_b <= denom) || + (denom < 0 && nume_a <= 0 && nume_a >= denom && nume_b <= 0 && nume_b >= denom)) { + double ua = nume_a / denom; + double ix = s1.first().lon() + ua*(s1.second().lon() - s1.first().lon()); + double iy = s1.first().lat() + ua*(s1.second().lat() - s1.first().lat()); + return osmium::Location(ix, iy); + } + } + + return osmium::Location(); + } + + } // namespace detail + + } // namespace area + +} // namespace osmium + +#endif // OSMIUM_AREA_DETAIL_NODE_REF_SEGMENT_HPP diff --git a/ThirdParty/osmium/area/detail/proto_ring.hpp b/ThirdParty/osmium/area/detail/proto_ring.hpp new file mode 100644 index 000000000..1dd236d21 --- /dev/null +++ b/ThirdParty/osmium/area/detail/proto_ring.hpp @@ -0,0 +1,274 @@ +#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 2014 Jochen Topf 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 +#include +#include +#include +#include +#include + +#include +#include + +namespace osmium { + + namespace area { + + namespace detail { + + /** + * A ring in the process of being built by the Assembler object. + */ + class ProtoRing { + + public: + + typedef std::vector 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 m_inner; + + public: + + explicit ProtoRing(const NodeRefSegment& segment) : + m_segments() { + add_segment_back(segment); + } + + explicit ProtoRing(segments_type::const_iterator sbegin, segments_type::const_iterator send) : + m_segments(static_cast(std::distance(sbegin, send))) { + std::copy(sbegin, send, m_segments.begin()); + } + + bool outer() const { + return m_outer; + } + + void set_inner() { + m_outer = false; + } + + segments_type& segments() { + return m_segments; + } + + const segments_type& segments() const { + 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 NodeRefSegment& get_segment_back() const { + return m_segments.back(); + } + + NodeRefSegment& get_segment_back() { + return m_segments.back(); + } + + 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(segment.first().location().x()) * static_cast(segment.second().location().y()) - + static_cast(segment.second().location().x()) * static_cast(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) { + std::swap(m_segments, other.m_segments); + } + + void add_inner_ring(ProtoRing* ring) { + m_inner.push_back(ring); + } + + const std::vector 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(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& 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 + inline std::basic_ostream& operator<<(std::basic_ostream& out, const ProtoRing& ring) { + ring.print(out); + return out; + } + + } // namespace detail + + } // namespace area + +} // namespace osmium + +#endif // OSMIUM_AREA_DETAIL_PROTO_RING_HPP diff --git a/ThirdParty/osmium/area/detail/segment_list.hpp b/ThirdParty/osmium/area/detail/segment_list.hpp new file mode 100644 index 000000000..dcee3d00a --- /dev/null +++ b/ThirdParty/osmium/area/detail/segment_list.hpp @@ -0,0 +1,216 @@ +#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 2014 Jochen Topf 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 +#include +#include +#include + +#include +#include +#include +#include +#include + +namespace osmium { + + namespace area { + + namespace detail { + + /** + * This is a helper class for the area assembler. It models + * a list of segments. + */ + class SegmentList { + + typedef std::vector slist_type; + + slist_type m_segments; + + bool m_debug; + + public: + + explicit SegmentList(bool debug) : + m_debug(debug) { + } + + ~SegmentList() = default; + + SegmentList(const SegmentList& other) = delete; + SegmentList(SegmentList&& other) = delete; + + SegmentList& operator=(const SegmentList& other) = delete; + SegmentList& operator=(SegmentList&& other) = delete; + + /// The number of segments in the list. + size_t size() const { + return m_segments.size(); + } + + bool empty() const { + return m_segments.empty(); + } + + typedef slist_type::const_iterator const_iterator; + + const_iterator begin() const { + return m_segments.begin(); + } + + const_iterator end() const { + return m_segments.end(); + } + + /** + * Enable or disable debug output to stderr. This is for Osmium + * developers only. + */ + void enable_debug_output(bool debug=true) { + 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& 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(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 diff --git a/ThirdParty/osmium/area/multipolygon_collector.hpp b/ThirdParty/osmium/area/multipolygon_collector.hpp new file mode 100644 index 000000000..24aa89c48 --- /dev/null +++ b/ThirdParty/osmium/area/multipolygon_collector.hpp @@ -0,0 +1,211 @@ +#ifndef OSMIUM_AREA_MULTIPOLYGON_COLLECTOR_HPP +#define OSMIUM_AREA_MULTIPOLYGON_COLLECTOR_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2014 Jochen Topf 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 +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +namespace osmium { + + struct invalid_location; + + namespace relations { + class RelationMeta; + } + + /** + * @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 + class MultipolygonCollector : public osmium::relations::Collector, false, true, false> { + + typedef typename osmium::relations::Collector, 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()) { + this->callback()(m_output_buffer); + m_output_buffer.clear(); + } + } + + 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) { + if (way.ends_have_same_location() && way.nodes().size() > 3) { + // way is closed and has enough nodes, build simple multipolygon + try { + 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 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 + } + + // clear member metas + for (const auto& member : relation.members()) { + if (member.ref() != 0) { + auto& mmv = this->member_meta(member.type()); + auto range = std::equal_range(mmv.begin(), mmv.end(), osmium::relations::MemberMeta(member.ref())); + assert(range.first != range.second); + + // if this is the last time this object was needed + // then mark it as removed + if (range.first + 1 == range.second) { + this->get_member(range.first->buffer_offset()).removed(true); + } + + for (auto it = range.first; it != range.second; ++it) { + if (relation.id() == this->get_relation(it->relation_pos()).id()) { + mmv.erase(it); + break; + } + } + } + } + } + + void flush() { + flush_output_buffer(); + } + + osmium::memory::Buffer read() { + osmium::memory::Buffer buffer(initial_output_buffer_size, osmium::memory::Buffer::auto_grow::yes); + std::swap(buffer, m_output_buffer); + return buffer; + } + + }; // class MultipolygonCollector + + } // namespace area + +} // namespace osmium + +#endif // OSMIUM_AREA_MULTIPOLYGON_COLLECTOR_HPP diff --git a/ThirdParty/osmium/area/problem_reporter.hpp b/ThirdParty/osmium/area/problem_reporter.hpp new file mode 100644 index 000000000..9e3eece8d --- /dev/null +++ b/ThirdParty/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 2014 Jochen Topf 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 +#include +#include + +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) { + 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 diff --git a/ThirdParty/osmium/area/problem_reporter_exception.hpp b/ThirdParty/osmium/area/problem_reporter_exception.hpp new file mode 100644 index 000000000..eebc553a8 --- /dev/null +++ b/ThirdParty/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 2014 Jochen Topf 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 +#include + +#include +#include +#include + +namespace osmium { + + namespace area { + + class ProblemReporterException : public ProblemReporterStream { + + std::stringstream m_sstream; + + public: + + ProblemReporterException() : + ProblemReporterStream(m_sstream) { + } + + virtual ~ProblemReporterException() = 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 diff --git a/ThirdParty/osmium/area/problem_reporter_ogr.hpp b/ThirdParty/osmium/area/problem_reporter_ogr.hpp new file mode 100644 index 000000000..f1bcf87ac --- /dev/null +++ b/ThirdParty/osmium/area/problem_reporter_ogr.hpp @@ -0,0 +1,202 @@ +#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 2014 Jochen Topf 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. + +*/ + +#define OSMIUM_COMPILE_WITH_CFLAGS_OGR `gdal-config --cflags` +#define OSMIUM_LINK_WITH_LIBS_OGR `gdal-config --libs` + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wold-style-cast" +#pragma GCC diagnostic ignored "-Wredundant-decls" +#pragma GCC diagnostic ignored "-Wshadow" +#pragma GCC diagnostic ignored "-Wdocumentation-unknown-command" +# include +# include +#pragma GCC diagnostic pop + +#include +#include + +#include +#include +#include +#include + +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; + + OGRDataSource* m_data_source; + + OGRLayer* m_layer_perror; + OGRLayer* m_layer_lerror; + + void write_point(const char* problem_type, osmium::object_id_type id1, osmium::object_id_type id2, osmium::Location location) { + OGRFeature* feature = OGRFeature::CreateFeature(m_layer_perror->GetLayerDefn()); + std::unique_ptr ogr_point = m_ogr_factory.create_point(location); + feature->SetGeometry(ogr_point.get()); + feature->SetField("id1", static_cast(id1)); + feature->SetField("id2", static_cast(id2)); + feature->SetField("problem_type", problem_type); + + if (m_layer_perror->CreateFeature(feature) != OGRERR_NONE) { + std::runtime_error("Failed to create feature on layer 'perrors'"); + } + + OGRFeature::DestroyFeature(feature); + } + + 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 ogr_point1 = m_ogr_factory.create_point(loc1); + std::unique_ptr ogr_point2 = m_ogr_factory.create_point(loc2); + std::unique_ptr ogr_linestring = std::unique_ptr(new OGRLineString()); + ogr_linestring->addPoint(ogr_point1.get()); + ogr_linestring->addPoint(ogr_point2.get()); + OGRFeature* feature = OGRFeature::CreateFeature(m_layer_lerror->GetLayerDefn()); + feature->SetGeometry(ogr_linestring.get()); + feature->SetField("id1", static_cast(id1)); + feature->SetField("id2", static_cast(id2)); + feature->SetField("problem_type", problem_type); + + if (m_layer_lerror->CreateFeature(feature) != OGRERR_NONE) { + std::runtime_error("Failed to create feature on layer 'lerrors'"); + } + + OGRFeature::DestroyFeature(feature); + } + + public: + + explicit ProblemReporterOGR(OGRDataSource* data_source) : + m_data_source(data_source) { + + OGRSpatialReference sparef; + sparef.SetWellKnownGeogCS("WGS84"); + + m_layer_perror = m_data_source->CreateLayer("perrors", &sparef, wkbPoint, nullptr); + if (!m_layer_perror) { + std::runtime_error("Layer creation failed for layer 'perrors'"); + } + + OGRFieldDefn layer_perror_field_id1("id1", OFTReal); + layer_perror_field_id1.SetWidth(10); + + if (m_layer_perror->CreateField(&layer_perror_field_id1) != OGRERR_NONE) { + std::runtime_error("Creating field 'id1' failed for layer 'perrors'"); + } + + OGRFieldDefn layer_perror_field_id2("id2", OFTReal); + layer_perror_field_id2.SetWidth(10); + + if (m_layer_perror->CreateField(&layer_perror_field_id2) != OGRERR_NONE) { + std::runtime_error("Creating field 'id2' failed for layer 'perrors'"); + } + + OGRFieldDefn layer_perror_field_problem_type("problem_type", OFTString); + layer_perror_field_problem_type.SetWidth(30); + + if (m_layer_perror->CreateField(&layer_perror_field_problem_type) != OGRERR_NONE) { + std::runtime_error("Creating field 'problem_type' failed for layer 'perrors'"); + } + + /**************/ + + m_layer_lerror = m_data_source->CreateLayer("lerrors", &sparef, wkbLineString, nullptr); + if (!m_layer_lerror) { + std::runtime_error("Layer creation failed for layer 'lerrors'"); + } + + OGRFieldDefn layer_lerror_field_id1("id1", OFTReal); + layer_lerror_field_id1.SetWidth(10); + + if (m_layer_lerror->CreateField(&layer_lerror_field_id1) != OGRERR_NONE) { + std::runtime_error("Creating field 'id1' failed for layer 'lerrors'"); + } + + OGRFieldDefn layer_lerror_field_id2("id2", OFTReal); + layer_lerror_field_id2.SetWidth(10); + + if (m_layer_lerror->CreateField(&layer_lerror_field_id2) != OGRERR_NONE) { + std::runtime_error("Creating field 'id2' failed for layer 'lerrors'"); + } + + OGRFieldDefn layer_lerror_field_problem_type("problem_type", OFTString); + layer_lerror_field_problem_type.SetWidth(30); + + if (m_layer_lerror->CreateField(&layer_lerror_field_problem_type) != OGRERR_NONE) { + std::runtime_error("Creating field 'problem_type' failed for layer 'lerrors'"); + } + } + + virtual ~ProblemReporterOGR() = 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 diff --git a/ThirdParty/osmium/area/problem_reporter_stream.hpp b/ThirdParty/osmium/area/problem_reporter_stream.hpp new file mode 100644 index 000000000..3ff2f20bb --- /dev/null +++ b/ThirdParty/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 2014 Jochen Topf 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 + +#include +#include +#include +#include + +namespace osmium { + + namespace area { + + class ProblemReporterStream : public ProblemReporter { + + std::ostream& m_out; + + public: + + explicit ProblemReporterStream(std::ostream& out) : + m_out(out) { + } + + virtual ~ProblemReporterStream() = 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 diff --git a/ThirdParty/osmium/builder/builder.hpp b/ThirdParty/osmium/builder/builder.hpp new file mode 100644 index 000000000..bd762be2c --- /dev/null +++ b/ThirdParty/osmium/builder/builder.hpp @@ -0,0 +1,179 @@ +#ifndef OSMIUM_BUILDER_BUILDER_HPP +#define OSMIUM_BUILDER_BUILDER_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include +#include + +#include +#include + +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, size_t 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(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) { + size_t padding = osmium::memory::align_bytes - (size() % osmium::memory::align_bytes); + if (padding != osmium::memory::align_bytes) { + std::memset(m_buffer.reserve_space(padding), 0, padding); + 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 { + return item().byte_size(); + } + + void add_item(const osmium::memory::Item* item) { + std::memcpy(m_buffer.reserve_space(item->padded_size()), item, item->padded_size()); + add_size(item->padded_size()); + } + + /** + * Reserve space for an object of class T in buffer and return + * pointer to it. + */ + template + T* reserve_space_for() { + assert(m_buffer.is_aligned()); + return reinterpret_cast(m_buffer.reserve_space(sizeof(T))); + } + + /** + * Append \0-terminated string to buffer. + */ + size_t append(const char* str) { + size_t length = std::strlen(str) + 1; + std::memcpy(m_buffer.reserve_space(length), str, length); + return length; + } + + /// Return the buffer this builder is using. + osmium::memory::Buffer& buffer() { + return m_buffer; + } + + }; // class Builder + + template + class ObjectBuilder : public Builder { + + public: + + explicit ObjectBuilder(osmium::memory::Buffer& buffer, Builder* parent=nullptr) : + Builder(buffer, parent, sizeof(T)) { + new (&item()) T(); + } + + T& object() { + return static_cast(item()); + } + + void add_user(const char* user) { + object().user_size(std::strlen(user) + 1); + add_size(append(user)); + add_padding(true); + } + + }; // class ObjectBuilder + + } // namespace builder + +} // namespace osmium + +#endif // OSMIUM_BUILDER_BUILDER_HPP diff --git a/ThirdParty/osmium/builder/builder_helper.hpp b/ThirdParty/osmium/builder/builder_helper.hpp new file mode 100644 index 000000000..3e00f81c4 --- /dev/null +++ b/ThirdParty/osmium/builder/builder_helper.hpp @@ -0,0 +1,103 @@ +#ifndef OSMIUM_BUILDER_BUILDER_HELPER_HPP +#define OSMIUM_BUILDER_BUILDER_HELPER_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include +#include + +#include +#include + +namespace osmium { + + class NodeRef; + class TagList; + class WayNodeList; + + namespace builder { + + inline const osmium::WayNodeList& build_way_node_list(osmium::memory::Buffer& buffer, const std::initializer_list& 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(pos); + } + + inline const osmium::TagList& build_tag_list(osmium::memory::Buffer& buffer, const std::initializer_list>& 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(pos); + } + + inline const osmium::TagList& build_tag_list_from_map(osmium::memory::Buffer& buffer, const std::map& 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(pos); + } + + inline const osmium::TagList& build_tag_list_from_func(osmium::memory::Buffer& buffer, std::function func) { + size_t pos = buffer.committed(); + { + osmium::builder::TagListBuilder tl_builder(buffer); + func(tl_builder); + } + buffer.commit(); + return buffer.get(pos); + } + + } // namespace builder + +} // namespace osmium + +#endif // OSMIUM_BUILDER_BUILDER_HELPER_HPP diff --git a/ThirdParty/osmium/builder/osm_object_builder.hpp b/ThirdParty/osmium/builder/osm_object_builder.hpp new file mode 100644 index 000000000..0fb26c8ae --- /dev/null +++ b/ThirdParty/osmium/builder/osm_object_builder.hpp @@ -0,0 +1,207 @@ +#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,2014 Jochen Topf 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 +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace osmium { + + namespace memory { + class Buffer; + } + + namespace builder { + + class TagListBuilder : public ObjectBuilder { + + public: + + explicit TagListBuilder(osmium::memory::Buffer& buffer, Builder* parent=nullptr) : + ObjectBuilder(buffer, parent) { + } + + ~TagListBuilder() { + add_padding(); + } + + void add_tag(const char* key, const char* value) { + add_size(append(key) + append(value)); + } + + }; // class TagListBuilder + + template + class NodeRefListBuilder : public ObjectBuilder { + + public: + + explicit NodeRefListBuilder(osmium::memory::Buffer& buffer, Builder* parent=nullptr) : + ObjectBuilder(buffer, parent) { + } + + ~NodeRefListBuilder() { + static_cast(this)->add_padding(); + } + + void add_node_ref(const NodeRef& node_ref) { + new (static_cast(this)->reserve_space_for()) osmium::NodeRef(node_ref); + static_cast(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 WayNodeListBuilder; + typedef NodeRefListBuilder OuterRingBuilder; + typedef NodeRefListBuilder InnerRingBuilder; + + class RelationMemberListBuilder : public ObjectBuilder { + + void add_role(osmium::RelationMember* member, const char* role) { + size_t length = std::strlen(role) + 1; + assert(length < std::numeric_limits::max()); + member->set_role_size(static_cast(length)); + add_size(append(role)); + add_padding(true); + } + + public: + + explicit RelationMemberListBuilder(osmium::memory::Buffer& buffer, Builder* parent=nullptr) : + ObjectBuilder(buffer, parent) { + } + + ~RelationMemberListBuilder() { + add_padding(); + } + + void add_member(osmium::item_type type, object_id_type ref, const char* role, const osmium::OSMObject* full_member = nullptr) { + osmium::RelationMember* member = reserve_space_for(); + new (member) osmium::RelationMember(ref, type, full_member != nullptr); + add_size(sizeof(RelationMember)); + add_role(member, role); + if (full_member) { + add_item(full_member); + } + } + + }; // class RelationMemberListBuilder + + template + class OSMObjectBuilder : public ObjectBuilder { + + public: + + explicit OSMObjectBuilder(osmium::memory::Buffer& buffer, Builder* parent=nullptr) : + ObjectBuilder(buffer, parent) { + static_cast(this)->reserve_space_for(); + static_cast(this)->add_size(sizeof(string_size_type)); + } + + void add_tags(const std::initializer_list>& tags) { + osmium::builder::TagListBuilder tl_builder(static_cast(this)->buffer(), this); + for (const auto& p : tags) { + tl_builder.add_tag(p.first, p.second); + } + } + + }; // class OSMObjectBuilder + + typedef OSMObjectBuilder NodeBuilder; + typedef OSMObjectBuilder RelationBuilder; + + class WayBuilder : public OSMObjectBuilder { + + public: + + explicit WayBuilder(osmium::memory::Buffer& buffer, Builder* parent=nullptr) : + OSMObjectBuilder(buffer, parent) { + } + + void add_node_refs(const std::initializer_list& 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 { + + public: + + explicit AreaBuilder(osmium::memory::Buffer& buffer, Builder* parent=nullptr) : + OSMObjectBuilder(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.id(osmium::object_id_to_area_id(source.id(), source.type())); + area.version(source.version()); + area.changeset(source.changeset()); + area.timestamp(source.timestamp()); + area.visible(source.visible()); + area.uid(source.uid()); + + add_user(source.user()); + } + + }; // class AreaBuilder + + typedef ObjectBuilder ChangesetBuilder; + + } // namespace builder + +} // namespace osmium + +#endif // OSMIUM_BUILDER_OSM_OBJECT_BUILDER_HPP diff --git a/ThirdParty/osmium/config/constexpr.hpp b/ThirdParty/osmium/config/constexpr.hpp new file mode 100644 index 000000000..3eddc84a2 --- /dev/null +++ b/ThirdParty/osmium/config/constexpr.hpp @@ -0,0 +1,43 @@ +#ifndef OSMIUM_CONFIG_CONSTEXPR_HPP +#define OSMIUM_CONFIG_CONSTEXPR_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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. + +*/ + +// Workaround for MSVC which doesn't support constexpr in all cases yet +#ifdef _MSC_VER +# define OSMIUM_CONSTEXPR +#else +# define OSMIUM_CONSTEXPR constexpr +#endif + +#endif // OSMIUM_CONFIG_CONSTEXPR_HPP diff --git a/ThirdParty/osmium/diff_handler.hpp b/ThirdParty/osmium/diff_handler.hpp new file mode 100644 index 000000000..986ee1819 --- /dev/null +++ b/ThirdParty/osmium/diff_handler.hpp @@ -0,0 +1,67 @@ +#ifndef OSMIUM_DIFF_HANDLER_HPP +#define OSMIUM_DIFF_HANDLER_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 + +namespace osmium { + + /** + * @brief Osmium diff handlers provide access to differences between OSM object versions + */ + namespace diff_handler { + + class DiffHandler { + + public: + + DiffHandler() { + } + + 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 diff --git a/ThirdParty/osmium/diff_iterator.hpp b/ThirdParty/osmium/diff_iterator.hpp new file mode 100644 index 000000000..3c485eba4 --- /dev/null +++ b/ThirdParty/osmium/diff_iterator.hpp @@ -0,0 +1,129 @@ +#ifndef OSMIUM_DIFF_ITERATOR_HPP +#define OSMIUM_DIFF_ITERATOR_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include + +#include + +namespace osmium { + + class OSMObject; + + template + class DiffIterator : public std::iterator { + + static_assert(std::is_base_of::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 { + assert(m_curr != m_end); + + TBasicIterator prev = m_prev; + if (prev->type() != m_curr->type() || prev->id() != m_curr->id()) { + prev = m_curr; + } + + TBasicIterator next = m_next; + if (next == m_end || next->type() != m_curr->type() || next->id() != m_curr->id()) { + next = m_curr; + } + + m_diff = osmium::DiffObject(*prev, *m_curr, *next); + } + + public: + + explicit DiffIterator(TBasicIterator begin, TBasicIterator end) : + m_prev(begin), + m_curr(begin), + m_next(begin == end ? begin : ++begin), + m_end(end) { + } + + DiffIterator(const DiffIterator& other) = default; + DiffIterator& operator=(const DiffIterator& other) = default; + + DiffIterator(DiffIterator&& other) = default; + DiffIterator& operator=(DiffIterator&& other) = default; + + 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 { + return m_curr == rhs.m_curr && m_end == rhs.m_end; + } + + bool operator!=(const DiffIterator& rhs) const { + return !(*this == rhs); + } + + reference operator*() const { + set_diff(); + return m_diff; + } + + pointer operator->() const { + set_diff(); + return &m_diff; + } + + }; // class DiffIterator + +} // namespace osmium + +#endif // OSMIUM_DIFF_ITERATOR_HPP diff --git a/ThirdParty/osmium/diff_visitor.hpp b/ThirdParty/osmium/diff_visitor.hpp new file mode 100644 index 000000000..a40df7df6 --- /dev/null +++ b/ThirdParty/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,2014 Jochen Topf 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 +#include +#include +#include +#include + +namespace osmium { + + namespace detail { + + template + inline void apply_diff_iterator_recurse(const osmium::DiffObject& diff, THandler& handler) { + switch (diff.type()) { + case osmium::item_type::node: + handler.node(static_cast(diff)); + break; + case osmium::item_type::way: + handler.way(static_cast(diff)); + break; + case osmium::item_type::relation: + handler.relation(static_cast(diff)); + break; + default: + throw osmium::unknown_type(); + } + } + + template + 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 + inline void apply_diff(TIterator it, TIterator end, THandlers&... handlers) { + typedef osmium::DiffIterator diff_iterator; + + diff_iterator dit(it, end); + diff_iterator dend(end, end); + + for (; dit != dend; ++dit) { + detail::apply_diff_iterator_recurse(*dit, handlers...); + } + } + + class OSMObject; + + template + inline void apply_diff(TSource& source, THandlers&... handlers) { + apply_diff(osmium::io::InputIterator {source}, + osmium::io::InputIterator {}, + handlers...); + } + + template + inline void apply_diff(osmium::memory::Buffer& buffer, THandlers&... handlers) { + apply_diff(buffer.begin(), buffer.end(), handlers...); + } + + template + 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 diff --git a/ThirdParty/osmium/dynamic_handler.hpp b/ThirdParty/osmium/dynamic_handler.hpp new file mode 100644 index 000000000..115c09d3d --- /dev/null +++ b/ThirdParty/osmium/dynamic_handler.hpp @@ -0,0 +1,195 @@ +#ifndef OSMIUM_DYNAMIC_HANDLER_HPP +#define OSMIUM_DYNAMIC_HANDLER_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include + +#include + +namespace osmium { + + class Node; + class Way; + class Relation; + class Area; + class Changeset; + + 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 \ +auto _name_##_dispatch(THandler& handler, const osmium::_type_& object, int) -> decltype(handler._name_(object), void()) { \ + handler._name_(object); \ +} \ +template \ +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 + auto flush_dispatch(THandler& handler, int) -> decltype(handler.flush(), void()) { + handler.flush(); + } + + template + void flush_dispatch(THandler&, long) {} + + template + class HandlerWrapper : public HandlerWrapperBase { + + THandler m_handler; + + public: + + template + HandlerWrapper(TArgs&&... args) : + m_handler(std::forward(args)...) { + } + + void node(const osmium::Node& node) override final { + node_dispatch(m_handler, node, 0); + } + + void way(const osmium::Way& way) override final { + way_dispatch(m_handler, way, 0); + } + + void relation(const osmium::Relation& relation) override final { + relation_dispatch(m_handler, relation, 0); + } + + void area(const osmium::Area& area) override final { + area_dispatch(m_handler, area, 0); + } + + void changeset(const osmium::Changeset& changeset) override final { + changeset_dispatch(m_handler, changeset, 0); + } + + void flush() override final { + flush_dispatch(m_handler, 0); + } + + }; // HandlerWrapper + + } // namespace detail + + class DynamicHandler : public osmium::handler::Handler { + + typedef std::unique_ptr impl_ptr; + impl_ptr m_impl; + + public: + + DynamicHandler() : + m_impl(impl_ptr(new osmium::handler::detail::HandlerWrapperBase)) { + } + + template + void set(TArgs&&... args) { + m_impl = impl_ptr(new osmium::handler::detail::HandlerWrapper(std::forward(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(); + } + + }; // DynamicHandler + + } // namspace handler + +} // namespace osmium + +#endif // OSMIUM_DYNAMIC_HANDLER_HPP diff --git a/ThirdParty/osmium/geom/coordinates.hpp b/ThirdParty/osmium/geom/coordinates.hpp new file mode 100644 index 000000000..694143c22 --- /dev/null +++ b/ThirdParty/osmium/geom/coordinates.hpp @@ -0,0 +1,106 @@ +#ifndef OSMIUM_GEOM_COORDINATES_HPP +#define OSMIUM_GEOM_COORDINATES_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include + +#include + +namespace osmium { + + namespace geom { + + namespace detail { + + /** + * Append double to string, removing superfluous '0' characters at + * the end. The decimal dot will also be removed if necessary. + */ + inline void double2string(std::string& s, double value) { + s += std::to_string(value); + + size_t len = s.size()-1; + while (s[len] == '0') --len; + if (s[len] == '.') --len; + + s.resize(len+1); + } + + } // namespace detail + + struct Coordinates { + + double x; + double y; + + explicit Coordinates(double cx, double cy) : 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) const { + osmium::geom::detail::double2string(s, x); + s += infix; + osmium::geom::detail::double2string(s, y); + } + + void append_to_string(std::string& s, const char prefix, const char infix, const char suffix) const { + s += prefix; + append_to_string(s, infix); + s += suffix; + } + + }; // struct coordinates + + inline bool operator==(const Coordinates& lhs, const Coordinates& rhs) { + return lhs.x == rhs.x && lhs.y == rhs.y; + } + + inline bool operator!=(const Coordinates& lhs, const Coordinates& rhs) { + return ! operator==(lhs, rhs); + } + + template + inline std::basic_ostream& operator<<(std::basic_ostream& out, const Coordinates& c) { + return out << '(' << c.x << ',' << c.y << ')'; + } + + } // namespace geom + +} // namespace osmium + +#endif // OSMIUM_GEOM_COORDINATES_HPP diff --git a/ThirdParty/osmium/geom/factory.hpp b/ThirdParty/osmium/geom/factory.hpp new file mode 100644 index 000000000..1be404848 --- /dev/null +++ b/ThirdParty/osmium/geom/factory.hpp @@ -0,0 +1,282 @@ +#ifndef OSMIUM_GEOM_FACTORY_HPP +#define OSMIUM_GEOM_FACTORY_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace osmium { + + struct geometry_error : public std::runtime_error { + + geometry_error(const std::string& what) : + std::runtime_error(what) { + } + + geometry_error(const char* what) : + std::runtime_error(what) { + } + + }; // 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. + }; + + /** + * 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. + }; + + /** + * 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 { + return 4326; + } + + std::string proj_string() const { + return "+proj=longlat +datum=WGS84 +no_defs"; + } + + }; // class IdentityProjection + + /** + * Geometry factory. + */ + template + 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 + GeometryFactory(TArgs&&... args) : + m_projection(), + m_impl(std::forward(args)...) { + } + + /** + * Constructor for explicitly initialized projection. Note that the + * projection is moved into the GeometryFactory. + */ + template + GeometryFactory(TProjection&& projection, TArgs&&... args) : + m_projection(std::move(projection)), + m_impl(std::forward(args)...) { + } + + 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) { + return create_point(node.location()); + } + + point_type create_point(const osmium::NodeRef& node_ref) { + return create_point(node_ref.location()); + } + + /* LineString */ + + template + 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 + 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 create_linestring(const osmium::WayNodeList& wnl, use_nodes un=use_nodes::unique, direction dir=direction::forward) { + m_impl.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 geometry_error("not enough points for linestring"); + } + + return m_impl.linestring_finish(num_points); + } + + linestring_type create_linestring(const osmium::Way& way, use_nodes un=use_nodes::unique, direction dir=direction::forward) { + return create_linestring(way.nodes(), un, dir); + } + + /* MultiPolygon */ + + multipolygon_type create_multipolygon(const osmium::Area& area) { + 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(*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 geometry_error("invalid area"); + } + + m_impl.multipolygon_polygon_finish(); + return m_impl.multipolygon_finish(); + } + + }; // class GeometryFactory + + } // namespace geom + +} // namespace osmium + +#endif // OSMIUM_GEOM_FACTORY_HPP diff --git a/ThirdParty/osmium/geom/geojson.hpp b/ThirdParty/osmium/geom/geojson.hpp new file mode 100644 index 000000000..89efc3831 --- /dev/null +++ b/ThirdParty/osmium/geom/geojson.hpp @@ -0,0 +1,149 @@ +#ifndef OSMIUM_GEOM_GEOJSON_HPP +#define OSMIUM_GEOM_GEOJSON_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include + +#include +#include + +namespace osmium { + + namespace geom { + + namespace detail { + + class GeoJSONFactoryImpl { + + std::string m_str; + + 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() = default; + + /* 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, '[', ',', ']'); + 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_str += ','; + } + + linestring_type linestring_finish(size_t /* num_points */) { + assert(!m_str.empty()); + std::string str; + std::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_str += ','; + } + + multipolygon_type multipolygon_finish() { + assert(!m_str.empty()); + m_str.back() = ']'; + m_str += "}"; + return std::move(m_str); + } + + }; // class GeoJSONFactoryImpl + + } // namespace detail + + template + using GeoJSONFactory = GeometryFactory; + + } // namespace geom + +} // namespace osmium + +#endif // OSMIUM_GEOM_GEOJSON_HPP diff --git a/ThirdParty/osmium/geom/geos.hpp b/ThirdParty/osmium/geom/geos.hpp new file mode 100644 index 000000000..877520b2c --- /dev/null +++ b/ThirdParty/osmium/geom/geos.hpp @@ -0,0 +1,224 @@ +#ifndef OSMIUM_GEOM_GEOS_HPP +#define OSMIUM_GEOM_GEOS_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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. + +*/ + +#define OSMIUM_COMPILE_WITH_CFLAGS_GEOS `geos-config --cflags` +#define OSMIUM_LINK_WITH_LIBS_GEOS `geos-config --libs` + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +// 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() : + geometry_error("geometry creation failed in GEOS library, see nested exception for details") { + } + + }; // struct geos_geometry_error + + namespace geom { + + namespace detail { + + class GEOSFactoryImpl { + + geos::geom::PrecisionModel m_precision_model; + geos::geom::GeometryFactory m_geos_factory; + + std::unique_ptr m_coordinate_sequence; + std::vector> m_rings; + std::vector> m_polygons; + + public: + + typedef std::unique_ptr point_type; + typedef std::unique_ptr linestring_type; + typedef std::unique_ptr polygon_type; + typedef std::unique_ptr multipolygon_type; + typedef std::unique_ptr ring_type; + + explicit GEOSFactoryImpl(int srid = -1) : + m_precision_model(), + m_geos_factory(&m_precision_model, srid) { + } + + /* 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&) { + THROW(osmium::geos_geometry_error()); + } + } + + /* LineString */ + + void linestring_start() { + try { + m_coordinate_sequence.reset(m_geos_factory.getCoordinateSequenceFactory()->create(static_cast(0), 2)); + } catch (geos::util::GEOSException&) { + THROW(osmium::geos_geometry_error()); + } + } + + 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&) { + THROW(osmium::geos_geometry_error()); + } + } + + linestring_type linestring_finish(size_t /* num_points */) { + try { + return linestring_type(m_geos_factory.createLineString(m_coordinate_sequence.release())); + } catch (geos::util::GEOSException&) { + THROW(osmium::geos_geometry_error()); + } + } + + /* 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; + std::transform(std::next(m_rings.begin(), 1), m_rings.end(), std::back_inserter(*inner_rings), [](std::unique_ptr& 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&) { + THROW(osmium::geos_geometry_error()); + } + } + + void multipolygon_outer_ring_start() { + try { + m_coordinate_sequence.reset(m_geos_factory.getCoordinateSequenceFactory()->create(static_cast(0), 2)); + } catch (geos::util::GEOSException&) { + THROW(osmium::geos_geometry_error()); + } + } + + void multipolygon_outer_ring_finish() { + try { + m_rings.emplace_back(m_geos_factory.createLinearRing(m_coordinate_sequence.release())); + } catch (geos::util::GEOSException&) { + THROW(osmium::geos_geometry_error()); + } + } + + void multipolygon_inner_ring_start() { + try { + m_coordinate_sequence.reset(m_geos_factory.getCoordinateSequenceFactory()->create(static_cast(0), 2)); + } catch (geos::util::GEOSException&) { + THROW(osmium::geos_geometry_error()); + } + } + + void multipolygon_inner_ring_finish() { + try { + m_rings.emplace_back(m_geos_factory.createLinearRing(m_coordinate_sequence.release())); + } catch (geos::util::GEOSException&) { + THROW(osmium::geos_geometry_error()); + } + } + + 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&) { + THROW(osmium::geos_geometry_error()); + } + } + + multipolygon_type multipolygon_finish() { + try { + auto polygons = new std::vector; + std::transform(m_polygons.begin(), m_polygons.end(), std::back_inserter(*polygons), [](std::unique_ptr& p) { + return p.release(); + }); + m_polygons.clear(); + return multipolygon_type(m_geos_factory.createMultiPolygon(polygons)); + } catch (geos::util::GEOSException&) { + THROW(osmium::geos_geometry_error()); + } + } + + }; // class GEOSFactoryImpl + + } // namespace detail + + template + using GEOSFactory = GeometryFactory; + + } // namespace geom + +} // namespace osmium + +#undef THROW + +#endif // OSMIUM_GEOM_GEOS_HPP diff --git a/ThirdParty/osmium/geom/haversine.hpp b/ThirdParty/osmium/geom/haversine.hpp new file mode 100644 index 000000000..5ce09b58d --- /dev/null +++ b/ThirdParty/osmium/geom/haversine.hpp @@ -0,0 +1,96 @@ +#ifndef OSMIUM_GEOM_HAVERSINE_HPP +#define OSMIUM_GEOM_HAVERSINE_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include + +#include +#include +#include +#include +#include +#include + +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 diff --git a/ThirdParty/osmium/geom/mercator_projection.hpp b/ThirdParty/osmium/geom/mercator_projection.hpp new file mode 100644 index 000000000..df0d47d8a --- /dev/null +++ b/ThirdParty/osmium/geom/mercator_projection.hpp @@ -0,0 +1,109 @@ +#ifndef OSMIUM_GEOM_MERCATOR_PROJECTION_HPP +#define OSMIUM_GEOM_MERCATOR_PROJECTION_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include + +#include +#include +#include + +namespace osmium { + + namespace geom { + + namespace detail { + + constexpr double EARTH_RADIUS_FOR_EPSG3857 = 6378137.0; + + 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 { + 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 diff --git a/ThirdParty/osmium/geom/ogr.hpp b/ThirdParty/osmium/geom/ogr.hpp new file mode 100644 index 000000000..c730de85c --- /dev/null +++ b/ThirdParty/osmium/geom/ogr.hpp @@ -0,0 +1,157 @@ +#ifndef OSMIUM_GEOM_OGR_HPP +#define OSMIUM_GEOM_OGR_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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. + +*/ + +#define OSMIUM_COMPILE_WITH_CFLAGS_OGR `gdal-config --cflags` +#define OSMIUM_LINK_WITH_LIBS_OGR `gdal-config --libs` + +#include +#include +#include + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdocumentation-unknown-command" +# include +#pragma GCC diagnostic pop + +#include +#include + +namespace osmium { + + namespace geom { + + namespace detail { + + class OGRFactoryImpl { + + public: + + typedef std::unique_ptr point_type; + typedef std::unique_ptr linestring_type; + typedef std::unique_ptr polygon_type; + typedef std::unique_ptr multipolygon_type; + typedef std::unique_ptr 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(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); + } + + /* 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 + using OGRFactory = GeometryFactory; + + } // namespace geom + +} // namespace osmium + +#endif // OSMIUM_GEOM_OGR_HPP diff --git a/ThirdParty/osmium/geom/projection.hpp b/ThirdParty/osmium/geom/projection.hpp new file mode 100644 index 000000000..2f9849fe7 --- /dev/null +++ b/ThirdParty/osmium/geom/projection.hpp @@ -0,0 +1,159 @@ +#ifndef OSMIUM_GEOM_PROJECTION_HPP +#define OSMIUM_GEOM_PROJECTION_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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. + +*/ + +#define OSMIUM_LINK_WITH_LIBS_PROJ -lproj + +#include +#include + +#include + +#include +#include +#include + +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); + } + }; + + std::unique_ptr m_crs; + + projPJ get() const { + return m_crs.get(); + } + + 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)) { + } + + bool is_latlong() const { + return pj_is_latlong(m_crs.get()); + } + + bool is_geocent() const { + return pj_is_geocent(m_crs.get()); + } + + /** + * 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 + */ + friend 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; + } + + }; // class CRS + + /** + * Functor that does projection from WGS84 (EPSG:4326) in 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 { + if (m_epsg == 4326) { + return Coordinates(location.lon(), location.lat()); + } else { + Coordinates 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 { + return m_epsg; + } + + std::string proj_string() const { + return m_proj_string; + } + + }; // class Projection + + } // namespace geom + +} // namespace osmium + +#endif // OSMIUM_GEOM_PROJECTION_HPP diff --git a/ThirdParty/osmium/geom/relations.hpp b/ThirdParty/osmium/geom/relations.hpp new file mode 100644 index 000000000..156837b6d --- /dev/null +++ b/ThirdParty/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,2014 Jochen Topf 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 +#include + +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 diff --git a/ThirdParty/osmium/geom/util.hpp b/ThirdParty/osmium/geom/util.hpp new file mode 100644 index 000000000..25ea74626 --- /dev/null +++ b/ThirdParty/osmium/geom/util.hpp @@ -0,0 +1,71 @@ +#ifndef OSMIUM_GEOM_UTIL_HPP +#define OSMIUM_GEOM_UTIL_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include + +namespace osmium { + + 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) { + return degree * (PI / 180.0); + } + + /// Convert angle from radians to degrees. + inline constexpr double rad_to_deg(double radians) { + return radians * (180.0 / PI); + } + + } // namespace geom + +} // namespace osmium + +#endif // OSMIUM_GEOM_UTIL_HPP diff --git a/ThirdParty/osmium/geom/wkb.hpp b/ThirdParty/osmium/geom/wkb.hpp new file mode 100644 index 000000000..ac4c47bc8 --- /dev/null +++ b/ThirdParty/osmium/geom/wkb.hpp @@ -0,0 +1,264 @@ +#ifndef OSMIUM_GEOM_WKB_HPP +#define OSMIUM_GEOM_WKB_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include + +#include +#include + +namespace osmium { + + namespace geom { + + enum class wkb_type : bool { + wkb = false, + ewkb = true + }; + + enum class out_type : bool { + binary = false, + hex = true + }; + + namespace detail { + + template + inline void str_push(std::string& str, T data) { + size_t size = str.size(); + str.resize(size + sizeof(T)); + std::memcpy(const_cast(&str[size]), reinterpret_cast(&data), sizeof(T)); + } + + inline std::string convert_to_hex(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 + }; + + /** + * Byte order marker in WKB geometry. + */ + enum class wkb_byte_order_type : uint8_t { + XDR = 0, // Big Endian + NDR = 1 // Little Endian + }; + + 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 { + str_push(str, wkb_byte_order_type::NDR); + 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(0)); + } + return offset; + } + + void set_size(const size_t offset, const uint32_t size) { + memcpy(&m_data[offset], &size, sizeof(uint32_t)); + } + + 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; + std::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(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(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; + std::swap(data, m_data); + + if (m_out_type == out_type::hex) { + return convert_to_hex(data); + } else { + return data; + } + } + + }; // class WKBFactoryImpl + + } // namespace detail + + template + using WKBFactory = GeometryFactory; + + } // namespace geom + +} // namespace osmium + +#endif // OSMIUM_GEOM_WKB_HPP diff --git a/ThirdParty/osmium/geom/wkt.hpp b/ThirdParty/osmium/geom/wkt.hpp new file mode 100644 index 000000000..dd12ad34e --- /dev/null +++ b/ThirdParty/osmium/geom/wkt.hpp @@ -0,0 +1,142 @@ +#ifndef OSMIUM_GEOM_WKT_HPP +#define OSMIUM_GEOM_WKT_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include + +#include +#include + +namespace osmium { + + namespace geom { + + namespace detail { + + class WKTFactoryImpl { + + std::string m_str; + + 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; + + /* Point */ + + point_type make_point(const osmium::geom::Coordinates& xy) const { + std::string str {"POINT"}; + xy.append_to_string(str, '(', ' ', ')'); + 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_str += ','; + } + + linestring_type linestring_finish(size_t /* num_points */) { + assert(!m_str.empty()); + std::string str; + std::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_str += ','; + } + + multipolygon_type multipolygon_finish() { + assert(!m_str.empty()); + m_str.back() = ')'; + return std::move(m_str); + } + + }; // class WKTFactoryImpl + + } // namespace detail + + template + using WKTFactory = GeometryFactory; + + } // namespace geom + +} // namespace osmium + +#endif // OSMIUM_GEOM_WKT_HPP diff --git a/ThirdParty/osmium/handler.hpp b/ThirdParty/osmium/handler.hpp new file mode 100644 index 000000000..88bfbaccf --- /dev/null +++ b/ThirdParty/osmium/handler.hpp @@ -0,0 +1,101 @@ +#ifndef OSMIUM_HANDLER_HPP +#define OSMIUM_HANDLER_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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. + +*/ + +namespace osmium { + + class OSMObject; + class Node; + class Way; + class Relation; + class Area; + class Changeset; + class TagList; + class WayNodeList; + class RelationMemberList; + class OuterRing; + class InnerRing; + + /** + * @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 flush() const { + } + + }; // class Handler + + } // namspace handler + +} // namespace osmium + +#endif // OSMIUM_HANDLER_HPP diff --git a/ThirdParty/osmium/handler/chain.hpp b/ThirdParty/osmium/handler/chain.hpp new file mode 100644 index 000000000..a7bf10e9a --- /dev/null +++ b/ThirdParty/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 2014 Jochen Topf 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 + +#include + +#define OSMIUM_CHAIN_HANDLER_CALL(_func_, _type_) \ + template \ + struct call_ ## _func_ { \ + void operator()(THandlers& handlers, osmium::_type_& object) { \ + std::get(handlers)._func_(object); \ + call_ ## _func_()(handlers, object); \ + } \ + }; \ + template \ + struct call_ ## _func_ { \ + 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 + class ChainHandler : public osmium::handler::Handler { + + typedef std::tuple handlers_type; + handlers_type m_handlers; + + template + struct call_flush { + void operator()(THandlers& handlers) { + std::get(handlers).flush(); + call_flush()(handlers); + } + }; + + template + struct call_flush { + void operator()(THandlers&) {} + }; + + 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 diff --git a/ThirdParty/osmium/handler/disk_store.hpp b/ThirdParty/osmium/handler/disk_store.hpp new file mode 100644 index 000000000..137670a18 --- /dev/null +++ b/ThirdParty/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,2014 Jochen Topf 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 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +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 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 diff --git a/ThirdParty/osmium/handler/dump.hpp b/ThirdParty/osmium/handler/dump.hpp new file mode 100644 index 000000000..63c66e39e --- /dev/null +++ b/ThirdParty/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,2014 Jochen Topf 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 +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +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 diff --git a/ThirdParty/osmium/handler/node_locations_for_ways.hpp b/ThirdParty/osmium/handler/node_locations_for_ways.hpp new file mode 100644 index 000000000..695eae010 --- /dev/null +++ b/ThirdParty/osmium/handler/node_locations_for_ways.hpp @@ -0,0 +1,148 @@ +#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,2014 Jochen Topf 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 +#include +#include +#include +#include +#include +#include +#include + +namespace osmium { + + namespace handler { + + typedef osmium::index::map::Dummy 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 + class NodeLocationsForWays : public osmium::handler::Handler { + + /// 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() 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(id, node.location()); + } else { + m_storage_neg.set(-id, node.location()); + } + } + + /** + * Get location of node with given id. + */ + osmium::Location get_node_location(const osmium::object_id_type id) const { + return id >= 0 ? m_storage_pos.get(id) : m_storage_neg.get(-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.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("not found"); + } + } + + }; // class NodeLocationsForWays + + } // namespace handler + +} // namespace osmium + +#endif // OSMIUM_HANDLER_NODE_LOCATIONS_FOR_WAYS_HPP diff --git a/ThirdParty/osmium/handler/object_relations.hpp b/ThirdParty/osmium/handler/object_relations.hpp new file mode 100644 index 000000000..5b5b01735 --- /dev/null +++ b/ThirdParty/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,2014 Jochen Topf 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 +#include +#include +#include +#include +#include +#include + +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 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 diff --git a/ThirdParty/osmium/index/detail/mmap_vector_anon.hpp b/ThirdParty/osmium/index/detail/mmap_vector_anon.hpp new file mode 100644 index 000000000..f06696150 --- /dev/null +++ b/ThirdParty/osmium/index/detail/mmap_vector_anon.hpp @@ -0,0 +1,78 @@ +#ifndef OSMIUM_DETAIL_MMAP_VECTOR_ANON_HPP +#define OSMIUM_DETAIL_MMAP_VECTOR_ANON_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 + +#include +#include + +namespace osmium { + + namespace detail { + + /** + * This class looks and behaves like STL vector, but uses mmap internally. + */ + template + class mmap_vector_anon : public mmap_vector_base { + + public: + + mmap_vector_anon() : + mmap_vector_base( + -1, + osmium::detail::mmap_vector_size_increment, + 0, + osmium::detail::typed_mmap::map(osmium::detail::mmap_vector_size_increment)) { + } + + void reserve(size_t new_capacity) { + if (new_capacity > this->capacity()) { + this->data(osmium::detail::typed_mmap::remap(this->data(), this->capacity(), new_capacity)); + this->m_capacity = new_capacity; + } + } + + }; // class mmap_vector_anon + + } // namespace detail + +} // namespace osmium + +#endif // __linux__ + +#endif // OSMIUM_DETAIL_MMAP_VECTOR_ANON_HPP diff --git a/ThirdParty/osmium/index/detail/mmap_vector_base.hpp b/ThirdParty/osmium/index/detail/mmap_vector_base.hpp new file mode 100644 index 000000000..7ff4af2ba --- /dev/null +++ b/ThirdParty/osmium/index/detail/mmap_vector_base.hpp @@ -0,0 +1,183 @@ +#ifndef OSMIUM_DETAIL_MMAP_VECTOR_BASE_HPP +#define OSMIUM_DETAIL_MMAP_VECTOR_BASE_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include + +#include + +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. This class can not be used + * on it's own. Use the derived classes mmap_vector_anon or + * mmap_vector_file. + */ + template class TDerived> + class mmap_vector_base { + + protected: + + int m_fd; + size_t m_capacity; + size_t m_size; + T* m_data; + + explicit mmap_vector_base(int fd, size_t capacity, size_t size, T* data) : + m_fd(fd), + m_capacity(capacity), + m_size(size), + m_data(data) { + } + + explicit mmap_vector_base(int fd, size_t capacity, size_t size) : + m_fd(fd), + m_capacity(capacity), + m_size(size), + m_data(osmium::detail::typed_mmap::grow_and_map(capacity, m_fd)) { + } + + void data(T* data) { + m_data = data; + } + + public: + + 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; + + ~mmap_vector_base() { + osmium::detail::typed_mmap::unmap(m_data, m_capacity); + } + + size_t capacity() const { + return m_capacity; + } + + size_t size() const { + return m_size; + } + + bool empty() const { + return m_size == 0; + } + + const T* data() const { + return m_data; + } + + T* data() { + return m_data; + } + + T& operator[](size_t n) { + return m_data[n]; + } + + T at(size_t n) const { + if (n >= m_size) { + throw std::out_of_range("out of range"); + } + return m_data[n]; + } + + void clear() { + m_size = 0; + } + + void shrink_to_fit() { + // XXX do something here + } + + void push_back(const T& value) { + if (m_size >= m_capacity) { + resize(m_size+1); + } + m_data[m_size] = value; + ++m_size; + } + + void resize(size_t new_size) { + if (new_size > this->capacity()) { + static_cast*>(this)->reserve(new_size + osmium::detail::mmap_vector_size_increment); + } + if (new_size > this->size()) { + new (this->data() + this->size()) T[new_size - this->size()]; + } + this->m_size = new_size; + } + + iterator begin() { + return m_data; + } + + iterator end() { + return m_data + m_size; + } + + const_iterator begin() const { + return m_data; + } + + const_iterator end() const { + return m_data + m_size; + } + + const_iterator cbegin() { + return m_data; + } + + const_iterator cend() { + return m_data + m_size; + } + + }; // class mmap_vector_base + + } // namespace detail + +} // namespace osmium + +#endif // OSMIUM_DETAIL_MMAP_VECTOR_BASE_HPP diff --git a/ThirdParty/osmium/index/detail/mmap_vector_file.hpp b/ThirdParty/osmium/index/detail/mmap_vector_file.hpp new file mode 100644 index 000000000..fe2f98a9e --- /dev/null +++ b/ThirdParty/osmium/index/detail/mmap_vector_file.hpp @@ -0,0 +1,83 @@ +#ifndef OSMIUM_DETAIL_MMAP_VECTOR_FILE_HPP +#define OSMIUM_DETAIL_MMAP_VECTOR_FILE_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 + +#include +#include +#include + +namespace osmium { + + namespace detail { + + /** + * This class looks and behaves like STL vector, but mmap's a file internally. + */ + template + class mmap_vector_file : public mmap_vector_base { + + public: + + explicit mmap_vector_file() : + mmap_vector_base( + osmium::detail::create_tmp_file(), + osmium::detail::mmap_vector_size_increment, + 0) { + } + + explicit mmap_vector_file(int fd) : + mmap_vector_base( + fd, + osmium::detail::typed_mmap::file_size(fd) == 0 ? osmium::detail::mmap_vector_size_increment : osmium::detail::typed_mmap::file_size(fd), + osmium::detail::typed_mmap::file_size(fd)) { + } + + void reserve(size_t new_capacity) { + if (new_capacity > this->capacity()) { + osmium::detail::typed_mmap::unmap(this->data(), this->capacity()); + osmium::detail::typed_mmap::grow_file(new_capacity, this->m_fd); + osmium::detail::typed_mmap::map(new_capacity, this->m_fd); + this->m_capacity = new_capacity; + } + } + + }; // class mmap_vector_file + + } // namespace detail + +} // namespace osmium + +#endif // OSMIUM_DETAIL_MMAP_VECTOR_FILE_HPP diff --git a/ThirdParty/osmium/index/detail/tmpfile.hpp b/ThirdParty/osmium/index/detail/tmpfile.hpp new file mode 100644 index 000000000..50c9cc9a5 --- /dev/null +++ b/ThirdParty/osmium/index/detail/tmpfile.hpp @@ -0,0 +1,62 @@ +#ifndef OSMIUM_DETAIL_TMPFILE_HPP +#define OSMIUM_DETAIL_TMPFILE_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include + +namespace osmium { + + namespace detail { + + /** + * Create and open a temporary file. It is removed after opening. + * + * @return File descriptor of temporary file. + * @exception 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_DETAIL_TMPFILE diff --git a/ThirdParty/osmium/index/detail/typed_mmap.hpp b/ThirdParty/osmium/index/detail/typed_mmap.hpp new file mode 100644 index 000000000..d064da2be --- /dev/null +++ b/ThirdParty/osmium/index/detail/typed_mmap.hpp @@ -0,0 +1,227 @@ +#ifndef OSMIUM_DETAIL_TYPED_MMAP_HPP +#define OSMIUM_DETAIL_TYPED_MMAP_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include + +#ifndef WIN32 +# include +#else +# include +#endif + +#include + +#ifdef _MSC_VER +# define ftruncate _chsize +#else +# include +#endif + +// for bsd systems +#ifndef MAP_ANONYMOUS +# define MAP_ANONYMOUS MAP_ANON +#endif + +namespace osmium { + + /** + * @brief Namespace for Osmium internal use + */ + namespace detail { + + /** + * This is a helper class for working with memory mapped files and + * anonymous shared memory. It wraps the necessary system calls + * adding: + * - error checking: all functions throw exceptions where needed + * - internal casts and size calculations allow use with user defined + * type T instead of void* + * + * This class only contains static functions. It should never be + * instantiated. + * + * @tparam T Type of objects we want to store. + */ + template + class typed_mmap { + + public: + + /** + * Create anonymous private memory mapping with enough space for size + * objects of type T. + * + * Note that no constructor is called for any of the objects in this memory! + * + * @param size Number of objects of type T that should fit into this memory + * @return Pointer to mapped memory + * @exception std::system_error If mmap(2) failed + */ + static T* map(size_t size) { + void* addr = ::mmap(nullptr, sizeof(T) * size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wold-style-cast" + if (addr == MAP_FAILED) { + throw std::system_error(errno, std::system_category(), "mmap failed"); + } +#pragma GCC diagnostic pop + return reinterpret_cast(addr); + } + + /** + * Create shared memory mapping of a file with enough space for size + * objects of type T. The file must already have at least the + * required size. + * + * Note that no constructor is called for any of the objects in this memory! + * + * @param size Number of objects of type T that should fit into this memory + * @param fd File descriptor + * @param write True if data should be writable + * @return Pointer to mapped memory + * @exception std::system_error If mmap(2) failed + */ + static T* map(size_t size, int fd, bool write = false) { + int prot = PROT_READ; + if (write) { + prot |= PROT_WRITE; + } + void* addr = ::mmap(nullptr, sizeof(T) * size, prot, MAP_SHARED, fd, 0); +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wold-style-cast" + if (addr == MAP_FAILED) { + throw std::system_error(errno, std::system_category(), "mmap failed"); + } +#pragma GCC diagnostic pop + return reinterpret_cast(addr); + } + +// mremap(2) is only available on linux systems +#ifdef __linux__ + /** + * Grow memory mapping created with map(). + * + * Note that no constructor is called for any of the objects in this memory! + * + * @param data Pointer to current mapping (as returned by typed_mmap()) + * @param old_size Number of objects currently stored in this memory + * @param new_size Number of objects we want to have space for + * @exception std::system_error If mremap(2) call failed + */ + static T* remap(T* data, size_t old_size, size_t new_size) { + void* addr = ::mremap(reinterpret_cast(data), sizeof(T) * old_size, sizeof(T) * new_size, MREMAP_MAYMOVE); +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wold-style-cast" + if (addr == MAP_FAILED) { + throw std::system_error(errno, std::system_category(), "mremap failed"); + } +#pragma GCC diagnostic pop + return reinterpret_cast(addr); + } +#endif + + /** + * Release memory from map() call. + * + * Note that no destructor is called for the objects in this memory! + * + * @param data Pointer to the data + * @param size Number of objects of type T stored + * @exception std::system_error If munmap(2) call failed + */ + static void unmap(T* data, size_t size) { + if (::munmap(reinterpret_cast(data), sizeof(T) * size) != 0) { + throw std::system_error(errno, std::system_category(), "munmap failed"); + } + } + + /** + * Get number of objects of type T that would fit into a file. + * + * @param fd File descriptor + * @return Number of objects of type T in this file + * @exception std::system_error If fstat(2) call failed + * @exception std::length_error If size of the file isn't a multiple of sizeof(T) + */ + static size_t file_size(int fd) { + struct stat s; + if (fstat(fd, &s) < 0) { + throw std::system_error(errno, std::system_category(), "fstat failed"); + } + if (s.st_size % sizeof(T) != 0) { + throw std::length_error("file size has to be multiple of object size"); + } + return s.st_size / sizeof(T); + } + + /** + * Grow file so there is enough space for at least new_size objects + * of type T. If the file is large enough already, nothing is done. + * The file is never shrunk. + * + * @param new_size Number of objects of type T that should fit into this file + * @param fd File descriptor + * @exception std::system_error If ftruncate(2) call failed + */ + static void grow_file(size_t new_size, int fd) { + if (file_size(fd) < new_size) { + if (::ftruncate(fd, sizeof(T) * new_size) < 0) { + throw std::system_error(errno, std::system_category(), "ftruncate failed"); + } + } + } + + /** + * Grow file to given size (if it is smaller) and mmap it. + * + * @param size Number of objects of type T that should fit into this file + * @param fd File descriptor + * @exception Errors thrown by grow_file() or map() + */ + static T* grow_and_map(size_t size, int fd) { + grow_file(size, fd); + return map(size, fd, true); + } + + }; // class typed_mmap + + } // namespace detail + +} // namespace osmium + +#endif // OSMIUM_DETAIL_TYPED_MMAP_HPP diff --git a/ThirdParty/osmium/index/index.hpp b/ThirdParty/osmium/index/index.hpp new file mode 100644 index 000000000..ece8ec444 --- /dev/null +++ b/ThirdParty/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,2014 Jochen Topf 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 +#include +#include +#include +#include + +#include + +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 + OSMIUM_NORETURN void not_found_error(TKey key) { + std::stringstream s; + s << "id " << key << " no 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 + 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 OSMIUM_CONSTEXPR size_t empty_value() { + return std::numeric_limits::max(); + } + + } // namespace index + +} // namespace osmium + +#endif // OSMIUM_INDEX_INDEX_HPP diff --git a/ThirdParty/osmium/index/map.hpp b/ThirdParty/osmium/index/map.hpp new file mode 100644 index 000000000..df865c727 --- /dev/null +++ b/ThirdParty/osmium/index/map.hpp @@ -0,0 +1,156 @@ +#ifndef OSMIUM_INDEX_MAP_HPP +#define OSMIUM_INDEX_MAP_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include + +#include // IWYU pragma: export + +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 + class Map { + + static_assert(std::is_integral::value && std::is_unsigned::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; + +// workaround for a bug in GCC 4.7 +#if __GNUC__ == 4 && __GNUC_MINOR__ < 8 + virtual ~Map() {} +#else + virtual ~Map() = default; +#endif + + 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 + } + + }; // class Map + + } // namespace map + + } // namespace index + +} // namespace osmium + +#endif // OSMIUM_INDEX_MAP_HPP diff --git a/ThirdParty/osmium/index/map/dummy.hpp b/ThirdParty/osmium/index/map/dummy.hpp new file mode 100644 index 000000000..b3239e81b --- /dev/null +++ b/ThirdParty/osmium/index/map/dummy.hpp @@ -0,0 +1,87 @@ +#ifndef OSMIUM_INDEX_MAP_DUMMY_HPP +#define OSMIUM_INDEX_MAP_DUMMY_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 + +#include + +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 + class Dummy : public osmium::index::map::Map { + + public: + + Dummy() = default; + + ~Dummy() override final = default; + + void set(const TId, const TValue) override final { + // intentionally left blank + } + + const TValue get(const TId id) const override final { + not_found_error(id); + } + + size_t size() const override final { + return 0; + } + + size_t used_memory() const override final { + return 0; + } + + void clear() override final { + } + + }; // class Dummy + + } // namespace map + + } // namespace index + +} // namespace osmium + +#endif // OSMIUM_INDEX_MAP_DUMMY_HPP diff --git a/ThirdParty/osmium/index/map/mmap_vector_anon.hpp b/ThirdParty/osmium/index/map/mmap_vector_anon.hpp new file mode 100644 index 000000000..863de2a72 --- /dev/null +++ b/ThirdParty/osmium/index/map/mmap_vector_anon.hpp @@ -0,0 +1,61 @@ +#ifndef OSMIUM_INDEX_MAP_MMAP_VECTOR_ANON_HPP +#define OSMIUM_INDEX_MAP_MMAP_VECTOR_ANON_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include + +namespace osmium { + + namespace index { + + namespace map { + + template + using DenseMapMmap = VectorBasedDenseMap, TId, TValue>; + + template + using SparseMapMmap = VectorBasedSparseMap; + + } // namespace map + + } // namespace index + +} // namespace osmium + +#endif // __linux__ + +#endif // OSMIUM_INDEX_MAP_MMAP_VECTOR_ANON_HPP diff --git a/ThirdParty/osmium/index/map/mmap_vector_file.hpp b/ThirdParty/osmium/index/map/mmap_vector_file.hpp new file mode 100644 index 000000000..7d178446d --- /dev/null +++ b/ThirdParty/osmium/index/map/mmap_vector_file.hpp @@ -0,0 +1,57 @@ +#ifndef OSMIUM_INDEX_MAP_MMAP_VECTOR_FILE_HPP +#define OSMIUM_INDEX_MAP_MMAP_VECTOR_FILE_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include + +namespace osmium { + + namespace index { + + namespace map { + + template + using DenseMapFile = VectorBasedDenseMap, TId, TValue>; + + template + using SparseMapFile = VectorBasedSparseMap; + + } // namespace map + + } // namespace index + +} // namespace osmium + +#endif // OSMIUM_INDEX_MAP_MMAP_VECTOR_FILE_HPP diff --git a/ThirdParty/osmium/index/map/sparse_table.hpp b/ThirdParty/osmium/index/map/sparse_table.hpp new file mode 100644 index 000000000..21eb6681d --- /dev/null +++ b/ThirdParty/osmium/index/map/sparse_table.hpp @@ -0,0 +1,140 @@ +#ifndef OSMIUM_INDEX_MAP_SPARSE_TABLE_HPP +#define OSMIUM_INDEX_MAP_SPARSE_TABLE_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include + +#include + +#include +#include + +namespace osmium { + + namespace index { + + namespace map { + + /** + * The SparseTable index stores elements in a Google sparsetable, + * a data structure that can hold sparsly filled tables in a + * very 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 + class SparseTable : public osmium::index::map::Map { + + TId m_grow_size; + + google::sparsetable m_elements; + + static_assert(sizeof(typename google::sparsetable::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 SparseTable(const TId grow_size=10000) : + m_grow_size(grow_size), + m_elements(grow_size) { + } + + ~SparseTable() override final = default; + + void set(const TId id, const TValue value) override final { + if (id >= m_elements.size()) { + m_elements.resize(id + m_grow_size); + } + m_elements[id] = value; + } + + const TValue get(const TId id) const override final { + if (id >= m_elements.size()) { + not_found_error(id); + } + if (m_elements[id] == osmium::index::empty_value()) { + not_found_error(id); + } + return m_elements[id]; + } + + size_t size() const override final { + return m_elements.size(); + } + + size_t used_memory() const override 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() override final { + m_elements.clear(); + } + + void dump_as_list(const int fd) const { + std::vector> v; + int n=0; + for (const TValue value : m_elements) { + if (value != osmium::index::empty_value()) { + v.emplace_back(n, value); + } + ++n; + } + osmium::io::detail::reliable_write(fd, reinterpret_cast(v.data()), sizeof(std::pair) * v.size()); + } + + }; // class SparseTable + + } // namespace map + + } // namespace index + +} // namespace osmium + +#endif // OSMIUM_INDEX_BYID_SPARSE_TABLE_HPP diff --git a/ThirdParty/osmium/index/map/stl_map.hpp b/ThirdParty/osmium/index/map/stl_map.hpp new file mode 100644 index 000000000..08458d55e --- /dev/null +++ b/ThirdParty/osmium/index/map/stl_map.hpp @@ -0,0 +1,112 @@ +#ifndef OSMIUM_INDEX_MAP_STL_MAP_HPP +#define OSMIUM_INDEX_MAP_STL_MAP_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include +#include +#include + +#include +#include + +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 + class StlMap : public osmium::index::map::Map { + + // 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 m_elements; + + public: + + StlMap() = default; + + ~StlMap() override final = default; + + void set(const TId id, const TValue value) override final { + m_elements[id] = value; + } + + const TValue get(const TId id) const override final { + try { + return m_elements.at(id); + } catch (std::out_of_range&) { + not_found_error(id); + } + } + + size_t size() const override final { + return m_elements.size(); + } + + size_t used_memory() const override final { + return element_size * m_elements.size(); + } + + void clear() override final { + m_elements.clear(); + } + + void dump_as_list(const int fd) const { + typedef typename std::map::value_type t; + std::vector v; + std::copy(m_elements.begin(), m_elements.end(), std::back_inserter(v)); + osmium::io::detail::reliable_write(fd, reinterpret_cast(v.data()), sizeof(t) * v.size()); + } + + }; // class StlMap + + } // namespace map + + } // namespace index + +} // namespace osmium + +#endif // OSMIUM_INDEX_MAP_STL_MAP_HPP diff --git a/ThirdParty/osmium/index/map/stl_vector.hpp b/ThirdParty/osmium/index/map/stl_vector.hpp new file mode 100644 index 000000000..238e9afa9 --- /dev/null +++ b/ThirdParty/osmium/index/map/stl_vector.hpp @@ -0,0 +1,61 @@ +#ifndef OSMIUM_INDEX_MAP_STL_VECTOR_HPP +#define OSMIUM_INDEX_MAP_STL_VECTOR_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 + +#include + +namespace osmium { + + namespace index { + + namespace map { + + template + using DenseMapMem = VectorBasedDenseMap, TId, TValue>; + + template + using StdVectorWrap = std::vector; + + template + using SparseMapMem = VectorBasedSparseMap; + + } // namespace map + + } // namespace index + +} // namespace osmium + +#endif // OSMIUM_INDEX_MAP_STL_VECTOR_HPP diff --git a/ThirdParty/osmium/index/map/vector.hpp b/ThirdParty/osmium/index/map/vector.hpp new file mode 100644 index 000000000..3e4890024 --- /dev/null +++ b/ThirdParty/osmium/index/map/vector.hpp @@ -0,0 +1,208 @@ +#ifndef OSMIUM_INDEX_MAP_VECTOR_HPP +#define OSMIUM_INDEX_MAP_VECTOR_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include + +#include +#include + +namespace osmium { + + namespace index { + + namespace map { + + template + class VectorBasedDenseMap : public Map { + + TVector m_vector; + + public: + + VectorBasedDenseMap() : + m_vector() { + } + + explicit VectorBasedDenseMap(int fd) : + m_vector(fd) { + } + + ~VectorBasedDenseMap() {} + + void reserve(const size_t size) override final { + m_vector.reserve(size); + } + + void set(const TId id, const TValue value) override final { + if (size() <= id) { + m_vector.resize(id+1); + } + m_vector[id] = value; + } + + const TValue get(const TId id) const override final { + try { + const TValue& value = m_vector.at(id); + if (value == osmium::index::empty_value()) { + not_found_error(id); + } + return value; + } catch (std::out_of_range&) { + not_found_error(id); + } + } + + size_t size() const override final { + return m_vector.size(); + } + + size_t used_memory() const override final { + return sizeof(TValue) * size(); + } + + void clear() override final { + m_vector.clear(); + m_vector.shrink_to_fit(); + } + + }; // class VectorBasedDenseMap + + + template class TVector> + class VectorBasedSparseMap : public Map { + + public: + + typedef typename std::pair element_type; + typedef TVector 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() { + } + + VectorBasedSparseMap(int fd) : + m_vector(fd) { + } + + ~VectorBasedSparseMap() override final = default; + + void set(const TId id, const TValue value) override final { + m_vector.push_back(element_type(id, value)); + } + + const TValue get(const TId id) const override final { + const element_type element { + id, + osmium::index::empty_value() + }; + 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 override final { + return m_vector.size(); + } + + size_t byte_size() const { + return m_vector.size() * sizeof(element_type); + } + + size_t used_memory() const override final { + return sizeof(element_type) * size(); + } + + void clear() override final { + m_vector.clear(); + m_vector.shrink_to_fit(); + } + + void sort() override final { + std::sort(m_vector.begin(), m_vector.end()); + } + + void dump_as_list(int fd) const { + osmium::io::detail::reliable_write(fd, reinterpret_cast(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_MAP_VECTOR_HPP diff --git a/ThirdParty/osmium/index/multimap.hpp b/ThirdParty/osmium/index/multimap.hpp new file mode 100644 index 000000000..bf20dfb26 --- /dev/null +++ b/ThirdParty/osmium/index/multimap.hpp @@ -0,0 +1,125 @@ +#ifndef OSMIUM_INDEX_MULTIMAP_HPP +#define OSMIUM_INDEX_MULTIMAP_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include + +#include // IWYU pragma: export + +namespace osmium { + + namespace index { + + /** + * @brief Key-value containers with multiple values for an integer key + */ + namespace multimap { + + template + class Multimap { + + static_assert(std::is_integral::value && std::is_unsigned::value, + "TId template parameter for class Multimap must be unsigned integral type"); + + typedef typename std::pair 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 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 + } + + }; // class Multimap + + } // namespace map + + } // namespace index + +} // namespace osmium + +#endif // OSMIUM_INDEX_MULTIMAP_HPP diff --git a/ThirdParty/osmium/index/multimap/hybrid.hpp b/ThirdParty/osmium/index/multimap/hybrid.hpp new file mode 100644 index 000000000..4214adc4e --- /dev/null +++ b/ThirdParty/osmium/index/multimap/hybrid.hpp @@ -0,0 +1,199 @@ +#ifndef OSMIUM_INDEX_MULTIMAP_HYBRID_HPP +#define OSMIUM_INDEX_MULTIMAP_HYBRID_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include + +#include +#include +#include + +namespace osmium { + + namespace index { + + namespace multimap { + + template + class HybridIterator { + + typedef SparseMultimapMem main_map_type; + typedef StlMultimap extra_map_type; + + typedef typename std::pair 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: + + explicit 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& 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()) { // ignore removed elements + ++m_begin_main; + } + } + return *this; + } + + HybridIterator 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*(); + } + + }; + + template + class Hybrid : public Multimap { + + typedef SparseMultimapMem main_map_type; + typedef StlMultimap extra_map_type; + + main_map_type m_main; + extra_map_type m_extra; + + public: + + typedef HybridIterator iterator; + typedef const HybridIterator const_iterator; + + Hybrid() : + m_main(), + m_extra() { + } + + size_t size() const override final { + return m_main.size() + m_extra.size(); + } + + size_t used_memory() const override 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) override final { + m_extra.set(id, value); + } + + std::pair 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(int fd) { + consolidate(); + m_main.dump_as_list(fd); + } + + void clear() override final { + m_main.clear(); + m_extra.clear(); + } + + void sort() override final { + m_main.sort(); + } + + }; // Hybrid + + } // namespace multimap + + } // namespace index + +} // namespace osmium + +#endif // OSMIUM_INDEX_MULTIMAP_HYBRID_HPP diff --git a/ThirdParty/osmium/index/multimap/mmap_vector_anon.hpp b/ThirdParty/osmium/index/multimap/mmap_vector_anon.hpp new file mode 100644 index 000000000..defb1eb37 --- /dev/null +++ b/ThirdParty/osmium/index/multimap/mmap_vector_anon.hpp @@ -0,0 +1,58 @@ +#ifndef OSMIUM_INDEX_MULTIMAP_MMAP_VECTOR_ANON_HPP +#define OSMIUM_INDEX_MULTIMAP_MMAP_VECTOR_ANON_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include + +namespace osmium { + + namespace index { + + namespace multimap { + + template + using SparseMultimapMmap = VectorBasedSparseMultimap; + + } // namespace multimap + + } // namespace index + +} // namespace osmium + +#endif // __linux__ + +#endif // OSMIUM_INDEX_MULTIMAP_MMAP_VECTOR_ANON_HPP diff --git a/ThirdParty/osmium/index/multimap/mmap_vector_file.hpp b/ThirdParty/osmium/index/multimap/mmap_vector_file.hpp new file mode 100644 index 000000000..b9b40ae4f --- /dev/null +++ b/ThirdParty/osmium/index/multimap/mmap_vector_file.hpp @@ -0,0 +1,54 @@ +#ifndef OSMIUM_INDEX_MULTIMAP_MMAP_VECTOR_FILE_HPP +#define OSMIUM_INDEX_MULTIMAP_MMAP_VECTOR_FILE_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include + +namespace osmium { + + namespace index { + + namespace multimap { + + template + using SparseMultimapFile = VectorBasedSparseMultimap; + + } // namespace multimap + + } // namespace index + +} // namespace osmium + +#endif // OSMIUM_INDEX_MULTIMAP_MMAP_VECTOR_FILE_HPP diff --git a/ThirdParty/osmium/index/multimap/stl_multimap.hpp b/ThirdParty/osmium/index/multimap/stl_multimap.hpp new file mode 100644 index 000000000..cd19c1560 --- /dev/null +++ b/ThirdParty/osmium/index/multimap/stl_multimap.hpp @@ -0,0 +1,151 @@ +#ifndef OSMIUM_INDEX_MULTIMAP_STL_MULTIMAP_HPP +#define OSMIUM_INDEX_MULTIMAP_STL_MULTIMAP_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include +#include + +#include +#include + +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 + class StlMultimap : public osmium::index::multimap::Multimap { + + // 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 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 element_type; + + private: + + collection_type m_elements; + + public: + + StlMultimap() = default; + + ~StlMultimap() noexcept override final = default; + + void unsorted_set(const TId id, const TValue value) { + m_elements.emplace(id, value); + } + + void set(const TId id, const TValue value) override final { + m_elements.emplace(id, value); + } + + std::pair get_all(const TId id) { + return m_elements.equal_range(id); + } + + std::pair get_all(const TId id) const { + return m_elements.equal_range(id); + } + + void remove(const TId id, const TValue value) { + std::pair 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 override final { + return m_elements.size(); + } + + size_t used_memory() const override final { + return element_size * m_elements.size(); + } + + void clear() override final { + m_elements.clear(); + } + + void consolidate() { + // intentionally left blank + } + + void dump_as_list(const int fd) const { + std::vector v; + for (const auto& element : m_elements) { + v.emplace_back(element.first, element.second); + } +// std::copy(m_elements.cbegin(), m_elements.cend(), std::back_inserter(v)); + std::sort(v.begin(), v.end()); + osmium::io::detail::reliable_write(fd, reinterpret_cast(v.data()), sizeof(element_type) * v.size()); + } + + }; // class StlMultimap + + } // namespace multimap + + } // namespace index + +} // namespace osmium + +#endif // OSMIUM_INDEX_MULTIMAP_STL_MULTIMAP_HPP diff --git a/ThirdParty/osmium/index/multimap/stl_vector.hpp b/ThirdParty/osmium/index/multimap/stl_vector.hpp new file mode 100644 index 000000000..2102824d5 --- /dev/null +++ b/ThirdParty/osmium/index/multimap/stl_vector.hpp @@ -0,0 +1,58 @@ +#ifndef OSMIUM_INDEX_MULTIMAP_STL_VECTOR_HPP +#define OSMIUM_INDEX_MULTIMAP_STL_VECTOR_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 + +#include + +namespace osmium { + + namespace index { + + namespace multimap { + + template + using StdVectorWrap = std::vector; + + template + using SparseMultimapMem = VectorBasedSparseMultimap; + + } // namespace multimap + + } // namespace index + +} // namespace osmium + +#endif // OSMIUM_INDEX_MULTIMAP_STL_VECTOR_HPP diff --git a/ThirdParty/osmium/index/multimap/vector.hpp b/ThirdParty/osmium/index/multimap/vector.hpp new file mode 100644 index 000000000..1a548a814 --- /dev/null +++ b/ThirdParty/osmium/index/multimap/vector.hpp @@ -0,0 +1,141 @@ +#ifndef OSMIUM_INDEX_MULTIMAP_VECTOR_HPP +#define OSMIUM_INDEX_MULTIMAP_VECTOR_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include + +#include +#include + +namespace osmium { + + namespace index { + + namespace multimap { + + template class TVector> + class VectorBasedSparseMultimap : public Multimap { + + public: + + typedef typename std::pair element_type; + typedef TVector 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(); + } + + public: + + void set(const TId id, const TValue value) override 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 get_all(const TId id) { + const element_type element { + id, + osmium::index::empty_value() + }; + return std::equal_range(m_vector.begin(), m_vector.end(), element, [](const element_type& a, const element_type& b) { + return a.first < b.first; + }); + } + + size_t size() const override final { + return m_vector.size(); + } + + size_t byte_size() const { + return m_vector.size() * sizeof(element_type); + } + + size_t used_memory() const override final { + return sizeof(element_type) * size(); + } + + void clear() override final { + m_vector.clear(); + m_vector.shrink_to_fit(); + } + + void sort() override 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(int fd) const { + osmium::io::detail::reliable_write(fd, reinterpret_cast(m_vector.data()), byte_size()); + } + + }; // class VectorBasedSparseMultimap + + } // namespace multimap + + } // namespace index + +} // namespace osmium + +#endif // OSMIUM_INDEX_MULTIMAP_VECTOR_HPP diff --git a/ThirdParty/osmium/io/any_compression.hpp b/ThirdParty/osmium/io/any_compression.hpp new file mode 100644 index 000000000..03ad5ce2b --- /dev/null +++ b/ThirdParty/osmium/io/any_compression.hpp @@ -0,0 +1,39 @@ +#ifndef OSMIUM_IO_ANY_COMPRESSION_HPP +#define OSMIUM_IO_ANY_COMPRESSION_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 // IWYU pragma: export +#include // IWYU pragma: export + +#endif // OSMIUM_IO_ANY_COMPRESSION_HPP diff --git a/ThirdParty/osmium/io/any_input.hpp b/ThirdParty/osmium/io/any_input.hpp new file mode 100644 index 000000000..f60ff1455 --- /dev/null +++ b/ThirdParty/osmium/io/any_input.hpp @@ -0,0 +1,41 @@ +#ifndef OSMIUM_IO_ANY_INPUT_HPP +#define OSMIUM_IO_ANY_INPUT_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 // IWYU pragma: export + +#include // IWYU pragma: export +#include // IWYU pragma: export + +#endif // OSMIUM_IO_ANY_INPUT_HPP diff --git a/ThirdParty/osmium/io/any_output.hpp b/ThirdParty/osmium/io/any_output.hpp new file mode 100644 index 000000000..9d97d7d93 --- /dev/null +++ b/ThirdParty/osmium/io/any_output.hpp @@ -0,0 +1,42 @@ +#ifndef OSMIUM_IO_ANY_OUTPUT_HPP +#define OSMIUM_IO_ANY_OUTPUT_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 // IWYU pragma: export + +#include // IWYU pragma: export +#include // IWYU pragma: export +#include // IWYU pragma: export + +#endif // OSMIUM_IO_ANY_OUTPUT_HPP diff --git a/ThirdParty/osmium/io/bzip2_compression.hpp b/ThirdParty/osmium/io/bzip2_compression.hpp new file mode 100644 index 000000000..1b6552528 --- /dev/null +++ b/ThirdParty/osmium/io/bzip2_compression.hpp @@ -0,0 +1,196 @@ +#ifndef OSMIUM_IO_BZIP2_COMPRESSION_HPP +#define OSMIUM_IO_BZIP2_COMPRESSION_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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. + +*/ + +#define OSMIUM_LINK_WITH_LIBS_BZ2LIB -lbz2 + +#include +#include +#include + +#include +#ifndef _MSC_VER +# include +#endif + +#include +#include +#include + +namespace osmium { + + namespace io { + + namespace detail { + + OSMIUM_NORETURN inline void throw_bzip2_error(const std::string& msg, int error) { + throw std::runtime_error("bzip2 error: " + msg + ": " + std::to_string(error)); + } + + } // namespace detail + + class Bzip2Compressor : public Compressor { + + FILE* m_file; + int m_bzerror; + BZFILE* m_bzfile; + + public: + + explicit Bzip2Compressor(int fd) : + Compressor(), + 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("write open failed", m_bzerror); + } + } + + ~Bzip2Compressor() override final { + this->close(); + } + + void write(const std::string& data) override final { + int error; + ::BZ2_bzWrite(&error, m_bzfile, const_cast(data.data()), data.size()); + if (error != BZ_OK && error != BZ_STREAM_END) { + detail::throw_bzip2_error("write failed", error); + } + } + + void close() override final { + if (m_bzfile) { + int error; + ::BZ2_bzWriteClose(&error, m_bzfile, 0, nullptr, nullptr); + m_bzfile = nullptr; + if (m_file) { + fclose(m_file); + } + if (error != BZ_OK) { + detail::throw_bzip2_error("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: + + 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("read open failed", m_bzerror); + } + } + + ~Bzip2Decompressor() override final { + this->close(); + } + + std::string read() override final { + if (m_stream_end) { + return std::string(); + } + std::string buffer(osmium::io::Decompressor::input_buffer_size, '\0'); + int error; + int nread = ::BZ2_bzRead(&error, m_bzfile, const_cast(buffer.data()), buffer.size()); + if (error != BZ_OK && error != BZ_STREAM_END) { + detail::throw_bzip2_error("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("get unused failed", error); + } + std::string unused_data(static_cast(unused), static_cast(nunused)); + ::BZ2_bzReadClose(&error, m_bzfile); + if (error != BZ_OK) { + detail::throw_bzip2_error("read close failed", error); + } + m_bzfile = ::BZ2_bzReadOpen(&error, m_file, 0, 0, const_cast(static_cast(unused_data.data())), unused_data.size()); + if (error != BZ_OK) { + detail::throw_bzip2_error("read open failed", error); + } + } else { + m_stream_end = true; + } + } + buffer.resize(static_cast(nread)); + return buffer; + } + + void close() override final { + if (m_bzfile) { + int error; + ::BZ2_bzReadClose(&error, m_bzfile); + m_bzfile = nullptr; + if (m_file) { + fclose(m_file); + } + if (error != BZ_OK) { + detail::throw_bzip2_error("read close failed", error); + } + } + } + + }; // class Bzip2Decompressor + + namespace { + + const bool registered_bzip2_compression = osmium::io::CompressionFactory::instance().register_compression(osmium::io::file_compression::bzip2, + [](int fd) { return new osmium::io::Bzip2Compressor(fd); }, + [](int fd) { return new osmium::io::Bzip2Decompressor(fd); } + ); + + } // anonymous namespace + + } // namespace io + +} // namespace osmium + +#endif // OSMIUM_IO_BZIP2_COMPRESSION_HPP diff --git a/ThirdParty/osmium/io/compression.hpp b/ThirdParty/osmium/io/compression.hpp new file mode 100644 index 000000000..5ac242ab0 --- /dev/null +++ b/ThirdParty/osmium/io/compression.hpp @@ -0,0 +1,240 @@ +#ifndef OSMIUM_IO_COMPRESSION_HPP +#define OSMIUM_IO_COMPRESSION_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include +#include +#include +#include +#ifndef _MSC_VER +#include +#else +#include +#endif +#include + +#include +#include +#include + +namespace osmium { + + namespace io { + + class Compressor { + + public: + + Compressor() = default; + + virtual ~Compressor() { + } + + virtual void write(const std::string& data) = 0; + + virtual void close() = 0; + + }; // class Compressor + + class Decompressor { + + public: + + static constexpr size_t input_buffer_size = 256 * 1024; + + Decompressor() = default; + + Decompressor(const Decompressor&) = delete; + Decompressor& operator=(const Decompressor&) = delete; + + Decompressor(Decompressor&&) = delete; + Decompressor& operator=(Decompressor&&) = delete; + + virtual ~Decompressor() { + } + + 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 create_compressor_type; + typedef std::function create_decompressor_type; + + private: + + typedef std::map> 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 std::runtime_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 create_decompressor) { + compression_map_type::value_type cc(compression, std::make_pair(create_compressor, create_decompressor)); + return m_callbacks.insert(cc).second; + } + + std::unique_ptr create_compressor(osmium::io::file_compression compression, int fd) { + auto it = m_callbacks.find(compression); + + if (it != m_callbacks.end()) { + return std::unique_ptr((it->second.first)(fd)); + } + + error(compression); + } + + std::unique_ptr create_decompressor(osmium::io::file_compression compression, int fd) { + auto it = m_callbacks.find(compression); + + if (it != m_callbacks.end()) { + return std::unique_ptr((it->second.second)(fd)); + } + + error(compression); + } + + }; // class CompressionFactory + + class NoCompressor : public Compressor { + + int m_fd; + + public: + + NoCompressor(int fd) : + Compressor(), + m_fd(fd) { + } + + ~NoCompressor() override final { + this->close(); + } + + void write(const std::string& data) override final { + osmium::io::detail::reliable_write(m_fd, data.data(), data.size()); + } + + void close() override final { + if (m_fd >= 0) { + ::close(m_fd); + m_fd = -1; + } + } + + }; // class NoCompressor + + class NoDecompressor : public Decompressor { + + int m_fd; + + public: + + NoDecompressor(int fd) : + Decompressor(), + m_fd(fd) { + } + + ~NoDecompressor() override final { + this->close(); + } + + std::string read() override final { + std::string buffer(osmium::io::Decompressor::input_buffer_size, '\0'); + ssize_t nread = ::read(m_fd, const_cast(buffer.data()), buffer.size()); + if (nread < 0) { + throw std::system_error(errno, std::system_category(), "Read failed"); + } + buffer.resize(static_cast(nread)); + return buffer; + } + + void close() override final { + if (m_fd >= 0) { + ::close(m_fd); + m_fd = -1; + } + } + + }; // class NoDecompressor + + namespace { + + const bool registered_no_compression = osmium::io::CompressionFactory::instance().register_compression(osmium::io::file_compression::none, + [](int fd) { return new osmium::io::NoCompressor(fd); }, + [](int fd) { return new osmium::io::NoDecompressor(fd); } + ); + + } // anonymous namespace + + } // namespace io + +} // namespace osmium + +#endif // OSMIUM_IO_COMPRESSION_HPP diff --git a/ThirdParty/osmium/io/detail/input_format.hpp b/ThirdParty/osmium/io/detail/input_format.hpp new file mode 100644 index 000000000..13e5ca7d7 --- /dev/null +++ b/ThirdParty/osmium/io/detail/input_format.hpp @@ -0,0 +1,160 @@ +#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,2014 Jochen Topf 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 +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +namespace osmium { + + namespace thread { + template class Queue; + } // namespace thread + + namespace io { + + namespace detail { + + /** + * Virtual base class for all classes reading OSM files in different + * formats. + * + * Do not use this class or derived classes directly. Use the + * osmium::io::Reader class instead. + */ + class InputFormat { + + protected: + + osmium::io::File m_file; + osmium::osm_entity_bits::type m_read_which_entities; + osmium::thread::Queue& m_input_queue; + osmium::io::Header m_header; + + explicit InputFormat(const osmium::io::File& file, osmium::osm_entity_bits::type read_which_entities, osmium::thread::Queue& input_queue) : + m_file(file), + m_read_which_entities(read_which_entities), + m_input_queue(input_queue) { + m_header.has_multiple_object_versions(m_file.has_multiple_object_versions()); + } + + InputFormat(const InputFormat&) = delete; + InputFormat(InputFormat&&) = delete; + + InputFormat& operator=(const InputFormat&) = delete; + InputFormat& operator=(InputFormat&&) = delete; + + public: + + virtual ~InputFormat() { + } + + virtual osmium::memory::Buffer read() = 0; + + virtual void close() { + } + + virtual osmium::io::Header header() { + return m_header; + } + + }; // class InputFormat + + /** + * This factory class is used to create objects that read OSM data + * written in a specified format. + * + * Do not use this class directly. Instead use the osmium::io::Reader + * class. + */ + class InputFormatFactory { + + public: + + typedef std::function&)> create_input_type; + + private: + + typedef std::map map_type; + + map_type m_callbacks; + + InputFormatFactory() : + m_callbacks() { + } + + public: + + static InputFormatFactory& instance() { + static InputFormatFactory factory; + return factory; + } + + bool register_input_format(osmium::io::file_format format, create_input_type create_function) { + if (! m_callbacks.insert(map_type::value_type(format, create_function)).second) { + return false; + } + return true; + } + + std::unique_ptr create_input(const osmium::io::File& file, osmium::osm_entity_bits::type read_which_entities, osmium::thread::Queue& input_queue) { + file.check(); + + auto it = m_callbacks.find(file.format()); + if (it != m_callbacks.end()) { + return std::unique_ptr((it->second)(file, read_which_entities, input_queue)); + } + + throw std::runtime_error(std::string("Support for input format '") + as_string(file.format()) + "' not compiled into this binary."); + } + + }; // class InputFormatFactory + + } // namespace detail + + } // namespace io + +} // namespace osmium + +#endif // OSMIUM_IO_DETAIL_INPUT_FORMAT_HPP diff --git a/ThirdParty/osmium/io/detail/opl_output_format.hpp b/ThirdParty/osmium/io/detail/opl_output_format.hpp new file mode 100644 index 000000000..e96d7345c --- /dev/null +++ b/ThirdParty/osmium/io/detail/opl_output_format.hpp @@ -0,0 +1,303 @@ +#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,2014 Jochen Topf 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#if BOOST_VERSION >= 104800 +# include +#else +# include +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace osmium { + + namespace io { + + class File; + + namespace detail { + + /** + * Writes out one buffer with OSM data in OPL format. + */ + class OPLOutputBlock : public osmium::handler::Handler { + + static constexpr size_t tmp_buffer_size = 100; + + osmium::memory::Buffer m_input_buffer; + + std::string m_out; + + char m_tmp_buffer[tmp_buffer_size+1]; + + template + void output_formatted(const char* format, TArgs&&... args) { +#ifndef _MSC_VER + int len = snprintf(m_tmp_buffer, tmp_buffer_size, format, std::forward(args)...); +#else + int len = _snprintf(m_tmp_buffer, tmp_buffer_size, format, std::forward(args)...); +#endif + assert(len > 0 && static_cast(len) < tmp_buffer_size); + m_out += m_tmp_buffer; + } + + void append_encoded_string(const std::string& data) { + boost::u8_to_u32_iterator it(data.cbegin(), data.cbegin(), data.cend()); + boost::u8_to_u32_iterator end(data.cend(), data.cend(), data.cend()); + boost::utf8_output_iterator> oit(std::back_inserter(m_out)); + + for (; it != end; ++it) { + uint32_t c = *it; + + // 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)) { + *oit = c; + } else { + m_out += '%'; + output_formatted("%04x", c); + } + } + } + + void write_meta(const osmium::OSMObject& object) { + output_formatted("%" PRId64 " v%d d", object.id(), 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: + + explicit OPLOutputBlock(osmium::memory::Buffer&& buffer) : + m_input_buffer(std::move(buffer)), + m_out(), + m_tmp_buffer() { + } + + OPLOutputBlock(const OPLOutputBlock&) = delete; + OPLOutputBlock& operator=(const OPLOutputBlock&) = delete; + + OPLOutputBlock(OPLOutputBlock&& other) = default; + OPLOutputBlock& operator=(OPLOutputBlock&& other) = default; + + std::string operator()() { + osmium::apply(m_input_buffer.cbegin(), m_input_buffer.cend(), *this); + + std::string out; + std::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()); + m_out += 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(" i%d u", 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'; + } + + }; // OPLOutputBlock + + class OPLOutputFormat : public osmium::io::detail::OutputFormat { + + OPLOutputFormat(const OPLOutputFormat&) = delete; + OPLOutputFormat& operator=(const OPLOutputFormat&) = delete; + + public: + + OPLOutputFormat(const osmium::io::File& file, data_queue_type& output_queue) : + OutputFormat(file, output_queue) { + } + + void write_buffer(osmium::memory::Buffer&& buffer) override final { + OPLOutputBlock output_block(std::move(buffer)); + m_output_queue.push(osmium::thread::Pool::instance().submit(std::move(output_block))); + while (m_output_queue.size() > 10) { + std::this_thread::sleep_for(std::chrono::milliseconds(100)); // XXX + } + } + + void close() override final { + std::string out; + std::promise promise; + m_output_queue.push(promise.get_future()); + promise.set_value(out); + } + + }; // class OPLOutputFormat + + namespace { + + const bool registered_opl_output = osmium::io::detail::OutputFormatFactory::instance().register_output_format(osmium::io::file_format::opl, + [](const osmium::io::File& file, data_queue_type& output_queue) { + return new osmium::io::detail::OPLOutputFormat(file, output_queue); + }); + + } // anonymous namespace + + } // namespace detail + + } // namespace io + +} // namespace osmium + +#endif // OSMIUM_IO_DETAIL_OPL_OUTPUT_FORMAT_HPP diff --git a/ThirdParty/osmium/io/detail/output_format.hpp b/ThirdParty/osmium/io/detail/output_format.hpp new file mode 100644 index 000000000..6ce28fbee --- /dev/null +++ b/ThirdParty/osmium/io/detail/output_format.hpp @@ -0,0 +1,156 @@ +#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,2014 Jochen Topf 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 +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +namespace osmium { + + namespace memory { + class Buffer; + } + + namespace io { + + namespace detail { + + typedef osmium::thread::Queue> data_queue_type; + + /** + * 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: + + osmium::io::File m_file; + data_queue_type& m_output_queue; + + public: + + explicit OutputFormat(const osmium::io::File& file, data_queue_type& output_queue) : + m_file(file), + m_output_queue(output_queue) { + } + + OutputFormat(const OutputFormat&) = delete; + OutputFormat(OutputFormat&&) = delete; + + OutputFormat& operator=(const OutputFormat&) = delete; + OutputFormat& operator=(OutputFormat&&) = delete; + + virtual ~OutputFormat() { + } + + virtual void write_header(const osmium::io::Header&) { + } + + virtual void write_buffer(osmium::memory::Buffer&&) = 0; + + virtual void close() = 0; + + }; // 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 create_output_type; + + private: + + typedef std::map 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 create_output(const osmium::io::File& file, data_queue_type& output_queue) { + file.check(); + + auto it = m_callbacks.find(file.format()); + if (it != m_callbacks.end()) { + return std::unique_ptr((it->second)(file, output_queue)); + } + + throw std::runtime_error(std::string("Support for output format '") + as_string(file.format()) + "' not compiled into this binary."); + } + + }; // class OutputFormatFactory + + } // namespace detail + + } // namespace io + +} // namespace osmium + +#endif // OSMIUM_IO_DETAIL_OUTPUT_FORMAT_HPP diff --git a/ThirdParty/osmium/io/detail/pbf.hpp b/ThirdParty/osmium/io/detail/pbf.hpp new file mode 100644 index 000000000..cb44bb039 --- /dev/null +++ b/ThirdParty/osmium/io/detail/pbf.hpp @@ -0,0 +1,79 @@ +#ifndef OSMIUM_IO_DETAIL_PBF_HPP +#define OSMIUM_IO_DETAIL_PBF_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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. + +*/ + +#define OSMIUM_LINK_WITH_LIBS_PBF -pthread -lz -lprotobuf-lite -losmpbf + +#include + +#include + +// needed for htonl and ntohl +#ifndef WIN32 +# include +#else +# include +#endif + +#include + +namespace osmium { + + inline item_type osmpbf_membertype_to_item_type(const OSMPBF::Relation::MemberType mt) { + switch (mt) { + case OSMPBF::Relation::NODE: + return item_type::node; + case OSMPBF::Relation::WAY: + return item_type::way; + case OSMPBF::Relation::RELATION: + return item_type::relation; + } + } + + inline OSMPBF::Relation::MemberType item_type_to_osmpbf_membertype(const item_type type) { + switch (type) { + case item_type::node: + return OSMPBF::Relation::NODE; + case item_type::way: + return OSMPBF::Relation::WAY; + case item_type::relation: + return OSMPBF::Relation::RELATION; + default: + throw std::runtime_error("Unknown relation member type"); + } + } + +} // namespace osmium + +#endif // OSMIUM_IO_DETAIL_PBF_HPP diff --git a/ThirdParty/osmium/io/detail/pbf_input_format.hpp b/ThirdParty/osmium/io/detail/pbf_input_format.hpp new file mode 100644 index 000000000..36430bea5 --- /dev/null +++ b/ThirdParty/osmium/io/detail/pbf_input_format.hpp @@ -0,0 +1,681 @@ +#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,2014 Jochen Topf 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include // IWYU pragma: export +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace osmium { + + namespace io { + + class File; + + namespace detail { + + class PBFPrimitiveBlockParser { + + static constexpr size_t initial_buffer_size = 10 * 1024; + + const void* m_data; + const size_t m_size; + + const OSMPBF::StringTable* m_stringtable; + int64_t m_lon_offset; + int64_t m_lat_offset; + int64_t m_date_factor; + int32_t m_granularity; + + osmium::osm_entity_bits::type m_read_types; + + osmium::memory::Buffer m_buffer; + + PBFPrimitiveBlockParser(const PBFPrimitiveBlockParser&) = delete; + PBFPrimitiveBlockParser(PBFPrimitiveBlockParser&&) = delete; + + PBFPrimitiveBlockParser& operator=(const PBFPrimitiveBlockParser&) = delete; + PBFPrimitiveBlockParser& operator=(PBFPrimitiveBlockParser&&) = delete; + + public: + + explicit PBFPrimitiveBlockParser(const void* data, const size_t size, osmium::osm_entity_bits::type read_types) : + m_data(data), + m_size(size), + m_stringtable(nullptr), + m_lon_offset(0), + m_lat_offset(0), + m_date_factor(1000), + m_granularity(100), + m_read_types(read_types), + m_buffer(initial_buffer_size) { + } + + ~PBFPrimitiveBlockParser() = default; + + osmium::memory::Buffer operator()() { + OSMPBF::PrimitiveBlock pbf_primitive_block; + if (!pbf_primitive_block.ParseFromArray(m_data, m_size)) { + throw std::runtime_error("Failed to parse PrimitiveBlock."); + } + + m_stringtable = &pbf_primitive_block.stringtable(); + m_lon_offset = pbf_primitive_block.lon_offset(); + m_lat_offset = pbf_primitive_block.lat_offset(); + m_date_factor = pbf_primitive_block.date_granularity() / 1000; + m_granularity = pbf_primitive_block.granularity(); + + for (int i=0; i < pbf_primitive_block.primitivegroup_size(); ++i) { + const OSMPBF::PrimitiveGroup& group = pbf_primitive_block.primitivegroup(i); + + if (group.has_dense()) { + if (m_read_types & osmium::osm_entity_bits::node) parse_dense_node_group(group); + } else if (group.ways_size() != 0) { + if (m_read_types & osmium::osm_entity_bits::way) parse_way_group(group); + } else if (group.relations_size() != 0) { + if (m_read_types & osmium::osm_entity_bits::relation) parse_relation_group(group); + } else if (group.nodes_size() != 0) { + if (m_read_types & osmium::osm_entity_bits::node) parse_node_group(group); + } else { + throw std::runtime_error("Group of unknown type."); + } + } + + return std::move(m_buffer); + } + + private: + + template + void parse_attributes(TBuilder& builder, const TPBFObject& pbf_object) { + auto& object = builder.object(); + + object.id(pbf_object.id()); + + if (pbf_object.has_info()) { + object.version(pbf_object.info().version()) + .changeset(pbf_object.info().changeset()) + .timestamp(pbf_object.info().timestamp() * m_date_factor) + .uid_from_signed(pbf_object.info().uid()); + if (pbf_object.info().has_visible()) { + object.visible(pbf_object.info().visible()); + } + builder.add_user(m_stringtable->s(pbf_object.info().user_sid()).data()); + } else { + builder.add_user(""); + } + } + + void parse_node_group(const OSMPBF::PrimitiveGroup& group) { + for (int i=0; i < group.nodes_size(); ++i) { + osmium::builder::NodeBuilder builder(m_buffer); + const OSMPBF::Node& pbf_node = group.nodes(i); + parse_attributes(builder, pbf_node); + + if (builder.object().visible()) { + builder.object().location(osmium::Location( + (pbf_node.lon() * m_granularity + m_lon_offset) / (OSMPBF::lonlat_resolution / osmium::Location::coordinate_precision), + (pbf_node.lat() * m_granularity + m_lat_offset) / (OSMPBF::lonlat_resolution / osmium::Location::coordinate_precision))); + } + + if (pbf_node.keys_size() > 0) { + osmium::builder::TagListBuilder tl_builder(m_buffer, &builder); + for (int tag=0; tag < pbf_node.keys_size(); ++tag) { + tl_builder.add_tag(m_stringtable->s(static_cast(pbf_node.keys(tag))).data(), + m_stringtable->s(static_cast(pbf_node.vals(tag))).data()); + } + } + + m_buffer.commit(); + } + } + + void parse_way_group(const OSMPBF::PrimitiveGroup& group) { + for (int i=0; i < group.ways_size(); ++i) { + osmium::builder::WayBuilder builder(m_buffer); + const OSMPBF::Way& pbf_way = group.ways(i); + parse_attributes(builder, pbf_way); + + if (pbf_way.refs_size() > 0) { + osmium::builder::WayNodeListBuilder wnl_builder(m_buffer, &builder); + int64_t ref = 0; + for (int n=0; n < pbf_way.refs_size(); ++n) { + ref += pbf_way.refs(n); + wnl_builder.add_node_ref(ref); + } + } + + if (pbf_way.keys_size() > 0) { + osmium::builder::TagListBuilder tl_builder(m_buffer, &builder); + for (int tag=0; tag < pbf_way.keys_size(); ++tag) { + tl_builder.add_tag(m_stringtable->s(static_cast(pbf_way.keys(tag))).data(), + m_stringtable->s(static_cast(pbf_way.vals(tag))).data()); + } + } + + m_buffer.commit(); + } + } + + void parse_relation_group(const OSMPBF::PrimitiveGroup& group) { + for (int i=0; i < group.relations_size(); ++i) { + osmium::builder::RelationBuilder builder(m_buffer); + const OSMPBF::Relation& pbf_relation = group.relations(i); + parse_attributes(builder, pbf_relation); + + if (pbf_relation.types_size() > 0) { + osmium::builder::RelationMemberListBuilder rml_builder(m_buffer, &builder); + int64_t ref = 0; + for (int n=0; n < pbf_relation.types_size(); ++n) { + ref += pbf_relation.memids(n); + rml_builder.add_member(osmpbf_membertype_to_item_type(pbf_relation.types(n)), ref, m_stringtable->s(pbf_relation.roles_sid(n)).data()); + } + } + + if (pbf_relation.keys_size() > 0) { + osmium::builder::TagListBuilder tl_builder(m_buffer, &builder); + for (int tag=0; tag < pbf_relation.keys_size(); ++tag) { + tl_builder.add_tag(m_stringtable->s(static_cast(pbf_relation.keys(tag))).data(), + m_stringtable->s(static_cast(pbf_relation.vals(tag))).data()); + } + } + + m_buffer.commit(); + } + } + + int add_tags(const OSMPBF::DenseNodes& dense, int n, osmium::builder::NodeBuilder* builder) { + if (n >= dense.keys_vals_size()) { + return n; + } + + if (dense.keys_vals(n) == 0) { + return n+1; + } + + osmium::builder::TagListBuilder tl_builder(m_buffer, builder); + + while (n < dense.keys_vals_size()) { + int tag_key_pos = dense.keys_vals(n++); + + if (tag_key_pos == 0) { + break; + } + + tl_builder.add_tag(m_stringtable->s(tag_key_pos).data(), + m_stringtable->s(dense.keys_vals(n)).data()); + + ++n; + } + + return n; + } + + void parse_dense_node_group(const OSMPBF::PrimitiveGroup& group) { + int64_t last_dense_id = 0; + int64_t last_dense_latitude = 0; + int64_t last_dense_longitude = 0; + int64_t last_dense_uid = 0; + int64_t last_dense_user_sid = 0; + int64_t last_dense_changeset = 0; + int64_t last_dense_timestamp = 0; + int last_dense_tag = 0; + + const OSMPBF::DenseNodes& dense = group.dense(); + + for (int i=0; i < dense.id_size(); ++i) { + bool visible = true; + + last_dense_id += dense.id(i); + last_dense_latitude += dense.lat(i); + last_dense_longitude += dense.lon(i); + + if (dense.has_denseinfo()) { + last_dense_changeset += dense.denseinfo().changeset(i); + last_dense_timestamp += dense.denseinfo().timestamp(i); + last_dense_uid += dense.denseinfo().uid(i); + last_dense_user_sid += dense.denseinfo().user_sid(i); + if (dense.denseinfo().visible_size() > 0) { + visible = dense.denseinfo().visible(i); + } + assert(last_dense_changeset >= 0); + assert(last_dense_timestamp >= 0); + assert(last_dense_uid >= -1); + assert(last_dense_user_sid >= 0); + } + + osmium::builder::NodeBuilder builder(m_buffer); + osmium::Node& node = builder.object(); + + node.id(last_dense_id); + + if (dense.has_denseinfo()) { + auto v = dense.denseinfo().version(i); + assert(v > 0); + node.version(static_cast(v)); + node.changeset(last_dense_changeset); + node.timestamp(last_dense_timestamp * m_date_factor); + node.uid_from_signed(last_dense_uid); + node.visible(visible); + builder.add_user(m_stringtable->s(last_dense_user_sid).data()); + } else { + builder.add_user(""); + } + + if (visible) { + builder.object().location(osmium::Location( + (last_dense_longitude * m_granularity + m_lon_offset) / (OSMPBF::lonlat_resolution / osmium::Location::coordinate_precision), + (last_dense_latitude * m_granularity + m_lat_offset) / (OSMPBF::lonlat_resolution / osmium::Location::coordinate_precision))); + } + + last_dense_tag = add_tags(dense, last_dense_tag, &builder); + m_buffer.commit(); + } + } + + }; // class PBFPrimitiveBlockParser + + typedef osmium::thread::Queue> queue_type; + + class InputQueueReader { + + osmium::thread::Queue& m_queue; + std::string m_buffer; + + public: + + InputQueueReader(osmium::thread::Queue& queue) : + m_queue(queue) { + } + + bool operator()(unsigned char* data, size_t size) { + while (m_buffer.size() < size) { + std::string new_data; + m_queue.wait_and_pop(new_data); + if (new_data.empty()) { + return false; + } + m_buffer += new_data; + } + memcpy(data, m_buffer.data(), size); + m_buffer.erase(0, size); + return true; + } + + }; + + template + class BlobParser { + + protected: + + std::shared_ptr m_input_buffer; + const int m_size; + const int m_blob_num; + InputQueueReader& m_input_queue_reader; + + BlobParser(const int size, const int blob_num, InputQueueReader& input_queue_reader) : + m_input_buffer(new unsigned char[size], [](unsigned char* ptr) { delete[] ptr; }), + m_size(size), + m_blob_num(blob_num), + m_input_queue_reader(input_queue_reader) { + if (size < 0 || size > OSMPBF::max_uncompressed_blob_size) { + std::ostringstream errmsg; + errmsg << "invalid blob size: " << size; + throw std::runtime_error(errmsg.str()); + } + if (! input_queue_reader(m_input_buffer.get(), size)) { + // EOF + throw std::runtime_error("read error (EOF)"); + } + } + + public: + + void doit() { + OSMPBF::Blob pbf_blob; + if (!pbf_blob.ParseFromArray(m_input_buffer.get(), m_size)) { + throw std::runtime_error("failed to parse blob"); + } + + if (pbf_blob.has_raw()) { + static_cast(this)->handle_blob(pbf_blob.raw()); + return; + } else if (pbf_blob.has_zlib_data()) { + auto raw_size = pbf_blob.raw_size(); + assert(raw_size >= 0); + assert(raw_size <= OSMPBF::max_uncompressed_blob_size); + + std::string unpack_buffer { osmium::io::detail::zlib_uncompress(pbf_blob.zlib_data(), static_cast(raw_size)) }; + static_cast(this)->handle_blob(unpack_buffer); + return; + } else if (pbf_blob.has_lzma_data()) { + throw std::runtime_error("lzma blobs not implemented"); + } else { + throw std::runtime_error("Blob contains no data"); + } + } + + osmium::memory::Buffer operator()() { + OSMPBF::Blob pbf_blob; + if (!pbf_blob.ParseFromArray(m_input_buffer.get(), m_size)) { + throw std::runtime_error("failed to parse blob"); + } + + if (pbf_blob.has_raw()) { + return static_cast(this)->handle_blob(pbf_blob.raw()); + } else if (pbf_blob.has_zlib_data()) { + auto raw_size = pbf_blob.raw_size(); + assert(raw_size >= 0); + assert(raw_size <= OSMPBF::max_uncompressed_blob_size); + + std::string unpack_buffer { osmium::io::detail::zlib_uncompress(pbf_blob.zlib_data(), static_cast(raw_size)) }; + return static_cast(this)->handle_blob(unpack_buffer); + } else if (pbf_blob.has_lzma_data()) { + throw std::runtime_error("lzma blobs not implemented"); + } else { + throw std::runtime_error("Blob contains no data"); + } + } + + }; // class BlobParser; + + class HeaderBlobParser : public BlobParser { + + osmium::io::Header& m_header; + + void handle_blob(const std::string& data) { + OSMPBF::HeaderBlock pbf_header_block; + if (!pbf_header_block.ParseFromArray(data.data(), data.size())) { + throw std::runtime_error("Failed to parse HeaderBlock."); + } + + for (int i=0; i < pbf_header_block.required_features_size(); ++i) { + const std::string& feature = pbf_header_block.required_features(i); + + if (feature == "OsmSchema-V0.6") continue; + if (feature == "DenseNodes") { + m_header.set("pbf_dense_nodes", true); + continue; + } + if (feature == "HistoricalInformation") { + m_header.has_multiple_object_versions(true); + continue; + } + + std::ostringstream errmsg; + errmsg << "Required feature not supported: " << feature; + throw std::runtime_error(errmsg.str()); + } + + if (pbf_header_block.has_writingprogram()) { + m_header.set("generator", pbf_header_block.writingprogram()); + } + + if (pbf_header_block.has_bbox()) { + const OSMPBF::HeaderBBox& pbf_bbox = pbf_header_block.bbox(); + const int64_t resolution_convert = OSMPBF::lonlat_resolution / osmium::Location::coordinate_precision; + osmium::Box box; + box.extend(osmium::Location(pbf_bbox.left() / resolution_convert, pbf_bbox.bottom() / resolution_convert)); + box.extend(osmium::Location(pbf_bbox.right() / resolution_convert, pbf_bbox.top() / resolution_convert)); + m_header.add_box(box); + } + + if (pbf_header_block.has_osmosis_replication_timestamp()) { + m_header.set("osmosis_replication_timestamp", osmium::Timestamp(pbf_header_block.osmosis_replication_timestamp()).to_iso()); + } + + if (pbf_header_block.has_osmosis_replication_sequence_number()) { + m_header.set("osmosis_replication_sequence_number", std::to_string(pbf_header_block.osmosis_replication_sequence_number())); + } + + if (pbf_header_block.has_osmosis_replication_base_url()) { + m_header.set("osmosis_replication_base_url", pbf_header_block.osmosis_replication_base_url()); + } + } + + public: + + friend class BlobParser; + + HeaderBlobParser(const int size, InputQueueReader& input_queue_reader, osmium::io::Header& header) : + BlobParser(size, 0, input_queue_reader), + m_header(header) { + } + + }; // class HeaderBlobParser + + class DataBlobParser : public BlobParser { + + osmium::osm_entity_bits::type m_read_types; + + osmium::memory::Buffer handle_blob(const std::string& data) { + PBFPrimitiveBlockParser parser(data.data(), data.size(), m_read_types); + return std::move(parser()); + } + + public: + + friend class BlobParser; + + DataBlobParser(const int size, const int blob_num, InputQueueReader& input_queue_reader, osmium::osm_entity_bits::type read_types) : + BlobParser(size, blob_num, input_queue_reader), + m_read_types(read_types) { + } + + }; // class DataBlobParser + + /** + * Class for parsing PBF files. + */ + class PBFInputFormat : public osmium::io::detail::InputFormat { + + bool m_use_thread_pool; + queue_type m_queue; + const size_t m_max_work_queue_size; + const size_t m_max_buffer_queue_size; + std::atomic m_done; + std::thread m_reader; + OSMPBF::BlobHeader m_blob_header; + InputQueueReader m_input_queue_reader; + + /** + * Read BlobHeader by first reading the size and then the BlobHeader. + * The BlobHeader contains a type field (which is checked against + * the expected type) and a size field. + * + * @param expected_type Expected type of data ("OSMHeader" or "OSMData"). + * @return Size of the data read from BlobHeader (0 on EOF). + */ + size_t read_blob_header(const char* expected_type) { + uint32_t size_in_network_byte_order; + + if (! m_input_queue_reader(reinterpret_cast(&size_in_network_byte_order), sizeof(size_in_network_byte_order))) { + return 0; // EOF + } + + uint32_t size = ntohl(size_in_network_byte_order); + if (size > static_cast(OSMPBF::max_blob_header_size)) { + throw std::runtime_error("Invalid BlobHeader size"); + } + + unsigned char blob_header_buffer[OSMPBF::max_blob_header_size]; + if (! m_input_queue_reader(blob_header_buffer, size)) { + throw std::runtime_error("Read error."); + } + + if (!m_blob_header.ParseFromArray(blob_header_buffer, static_cast(size))) { + throw std::runtime_error("Failed to parse BlobHeader."); + } + + if (std::strcmp(m_blob_header.type().c_str(), expected_type)) { + throw std::runtime_error("Blob does not have expected type (OSMHeader in first Blob, OSMData in following Blobs)."); + } + + return static_cast(m_blob_header.datasize()); + } + + void parse_osm_data(osmium::osm_entity_bits::type read_types) { + osmium::thread::set_thread_name("_osmium_pbf_in"); + int n=0; + while (size_t size = read_blob_header("OSMData")) { + DataBlobParser data_blob_parser(size, n, m_input_queue_reader, read_types); + + if (m_use_thread_pool) { + m_queue.push(osmium::thread::Pool::instance().submit(data_blob_parser)); + + // if the work queue is getting too large, wait for a while + while (!m_done && osmium::thread::Pool::instance().queue_size() >= m_max_work_queue_size) { + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + } + } else { + std::promise promise; + m_queue.push(promise.get_future()); + promise.set_value(data_blob_parser()); + } + ++n; + + // wait if the backlog of buffers with parsed data is too large + while (!m_done && m_queue.size() > m_max_buffer_queue_size) { + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + } + + if (m_done) { + return; + } + } + m_done = true; + } + + public: + + /** + * Instantiate PBF Parser + * + * @param file osmium::io::File instance describing file to be read from. + * @param read_which_entities Which types of OSM entities (nodes, ways, relations, changesets) should be parsed? + * @param input_queue String queue where data is read from. + */ + PBFInputFormat(const osmium::io::File& file, osmium::osm_entity_bits::type read_which_entities, osmium::thread::Queue& input_queue) : + osmium::io::detail::InputFormat(file, read_which_entities, input_queue), + m_use_thread_pool(true), + m_queue(), + m_max_work_queue_size(10), // XXX tune these settings + m_max_buffer_queue_size(20), // XXX tune these settings + m_done(false), + m_input_queue_reader(input_queue) { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + // handle OSMHeader + size_t size = read_blob_header("OSMHeader"); + + { + HeaderBlobParser header_blob_parser(size, m_input_queue_reader, m_header); + header_blob_parser.doit(); + } + + if (m_read_which_entities != osmium::osm_entity_bits::nothing) { + m_reader = std::thread(&PBFInputFormat::parse_osm_data, this, m_read_which_entities); + } + } + + ~PBFInputFormat() { + m_done = true; + if (m_reader.joinable()) { + m_reader.join(); + } + } + + /** + * Returns the next buffer with OSM data read from the PBF file. + * Blocks if data is not available yet. + * Returns an empty buffer at end of input. + */ + osmium::memory::Buffer read() override { + if (!m_done || !m_queue.empty()) { + std::future buffer_future; + m_queue.wait_and_pop(buffer_future); + return std::move(buffer_future.get()); + } + + return osmium::memory::Buffer(); + } + + }; // class PBFInputFormat + + namespace { + + const bool registered_pbf_input = osmium::io::detail::InputFormatFactory::instance().register_input_format(osmium::io::file_format::pbf, + [](const osmium::io::File& file, osmium::osm_entity_bits::type read_which_entities, osmium::thread::Queue& input_queue) { + return new osmium::io::detail::PBFInputFormat(file, read_which_entities, input_queue); + }); + + } // anonymous namespace + + } // namespace detail + + } // namespace io + +} // namespace osmium + +#endif // OSMIUM_IO_DETAIL_PBF_INPUT_FORMAT_HPP diff --git a/ThirdParty/osmium/io/detail/pbf_output_format.hpp b/ThirdParty/osmium/io/detail/pbf_output_format.hpp new file mode 100644 index 000000000..d24062c20 --- /dev/null +++ b/ThirdParty/osmium/io/detail/pbf_output_format.hpp @@ -0,0 +1,950 @@ +#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,2014 Jochen Topf 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. + +*/ + +/* + +About the .osm.pbf file format +This is an excerpt of + +The .osm.pbf format and it's derived formats (.osh.pbf and .osc.pbf) are encoded +using googles protobuf library for the low-level storage. They are constructed +by nesting data on two levels: + +On the lower level the file is constructed using BlobHeaders and Blobs. A .osm.pbf +file contains multiple sequences of + 1. a 4-byte header size, stored in network-byte-order + 2. a BlobHeader of exactly this size + 3. a Blob + +The BlobHeader tells the reader about the type and size of the following Blob. The +Blob can contain data in raw or zlib-compressed form. After uncompressing the blob +it is treated differently depending on the type specified in the BlobHeader. + +The contents of the Blob belongs to the higher level. It contains either an HeaderBlock +(type="OSMHeader") or an PrimitiveBlock (type="OSMData"). The file needs to have +at least one HeaderBlock before the first PrimitiveBlock. + +The HeaderBlock contains meta-information like the writing program or a bbox. It may +also contain multiple "required features" that describe what kinds of input a +reading program needs to handle in order to fully understand the files' contents. + +The PrimitiveBlock can store multiple types of objects (i.e. 5 nodes, 2 ways and +1 relation). It contains one or more PrimitiveGroup which in turn contain multiple +nodes, ways or relations. A PrimitiveGroup should only contain one kind of object. + +There's a special kind of "object type" called dense-nodes. It is used to store nodes +in a very dense format, avoiding message overheads and using delta-encoding for nearly +all ids. + +All Strings are stored as indexes to rows in a StringTable. The StringTable contains +one row for each used string, so strings that are used multiple times need to be +stored only once. The StringTable is sorted by usage-count, so the most often used +string is stored at index 1. + +A simple outline of a .osm.pbf file could look like this: + + 4-bytes header size + BlobHeader + Blob + HeaderBlock + 4-bytes header size + BlobHeader + Blob + PrimitiveBlock + StringTable + PrimitiveGroup + 5 nodes + PrimitiveGroup + 2 ways + PrimitiveGroup + 1 relation + +More complete outlines of real .osm.pbf files can be created using the osmpbf-outline tool: + +*/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include // IWYU pragma: export +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace osmium { + + namespace io { + + namespace detail { + + namespace { + + /** + * Serialize a protobuf message into a Blob, optionally apply compression + * and return it together with a BlobHeader ready to be written to a file. + * + * @param type Type-string used in the BlobHeader. + * @param msg Protobuf-message. + * @param use_compression Should the output be compressed using zlib? + */ + std::string serialize_blob(const std::string& type, const google::protobuf::MessageLite& msg, bool use_compression) { + OSMPBF::Blob pbf_blob; + + { + std::string content; + msg.SerializeToString(&content); + + pbf_blob.set_raw_size(content.size()); + + if (use_compression) { + pbf_blob.set_zlib_data(osmium::io::detail::zlib_compress(content)); + } else { + pbf_blob.set_raw(content); + } + } + + std::string blob_data; + pbf_blob.SerializeToString(&blob_data); + + OSMPBF::BlobHeader pbf_blob_header; + pbf_blob_header.set_type(type); + pbf_blob_header.set_datasize(blob_data.size()); + + std::string blob_header_data; + pbf_blob_header.SerializeToString(&blob_header_data); + + uint32_t sz = htonl(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(&sz), sizeof(sz)); + output.append(blob_header_data); + output.append(blob_data); + + return output; + } + + } // anonymous namespace + + class PBFOutputFormat : public osmium::io::detail::OutputFormat, public osmium::handler::Handler { + + /** + * This class models a variable that keeps track of the value + * it was last set to and returns the delta between old and + * new value from the update() call. + */ + template + class Delta { + + T m_value; + + public: + + Delta() : + m_value(0) { + } + + void clear() { + m_value = 0; + } + + T update(T new_value) { + using std::swap; + swap(m_value, new_value); + return m_value - new_value; + } + + }; // class Delta + + /** + * 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. + */ + static constexpr uint32_t max_block_contents = 8000; + + /** + * 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). + */ + static constexpr int buffer_fill_percent = 95; + + /** + * protobuf-struct of a HeaderBlock + */ + OSMPBF::HeaderBlock pbf_header_block; + + /** + * protobuf-struct of a PrimitiveBlock + */ + OSMPBF::PrimitiveBlock pbf_primitive_block; + + /** + * pointer to PrimitiveGroups inside the current PrimitiveBlock, + * used for writing nodes, ways or relations + */ + OSMPBF::PrimitiveGroup* pbf_nodes; + OSMPBF::PrimitiveGroup* pbf_ways; + OSMPBF::PrimitiveGroup* pbf_relations; + + /** + * To flexibly handle multiple resolutions, the granularity, or + * resolution used for representing locations is adjustable in + * multiples of 1 nanodegree. The default scaling factor is 100 + * nanodegrees, corresponding to about ~1cm at the equator. + * This is the current resolution of the OSM database. + */ + int m_location_granularity; + + /** + * The granularity used for representing timestamps is also adjustable in + * multiples of 1 millisecond. The default scaling factor is 1000 + * milliseconds, which is the current resolution of the OSM database. + */ + int m_date_granularity; + + /** + * should nodes be serialized into the dense format? + * + * nodes can be encoded one of two ways, as a Node + * (m_use_dense_nodes = false) and a special dense format. + * In the dense format, all information is stored 'column wise', + * as an array of ID's, array of latitudes, and array of + * longitudes. Each column is delta-encoded. This reduces + * header overheads and allows delta-coding to work very effectively. + */ + bool m_use_dense_nodes {true}; + + /** + * 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 m_use_compression {true}; + + /** + * While the .osm.pbf-format is able to carry all meta information, it is + * also able to omit this information to reduce size. + */ + bool m_should_add_metadata {true}; + + /** + * Should the visible flag be added on objects? + */ + bool m_add_visible; + + /** + * counter used to quickly check the number of objects stored inside + * the current PrimitiveBlock. When the counter reaches max_block_contents + * the PrimitiveBlock is serialized into a Blob and flushed to the file. + * + * this check is performed in check_block_contents_counter() which is + * called once for each object. + */ + uint16_t primitive_block_contents; + uint32_t primitive_block_size; + + // StringTable management + StringTable string_table; + + /** + * These variables are used to calculate the + * delta-encoding while storing dense-nodes. It holds the last seen values + * from which the difference is stored into the protobuf. + */ + Delta m_delta_id; + Delta m_delta_lat; + Delta m_delta_lon; + Delta m_delta_timestamp; + Delta m_delta_changeset; + Delta m_delta_uid; + Delta m_delta_user_sid; + + bool debug; + + bool has_debug_level(int) { + return false; + } + + ///// Blob writing ///// + + /** + * Before a PrimitiveBlock gets serialized, all interim StringTable-ids needs to be + * mapped to the associated real StringTable ids. This is done in this function. + * + * This function needs to know about the concrete structure of all item types to find + * all occurrences of string-ids. + */ + void map_string_ids() { + // test, if the node-block has been allocated + if (pbf_nodes) { + // iterate over all nodes, passing them to the map_common_string_ids function + for (int i=0, l=pbf_nodes->nodes_size(); imutable_nodes(i)); + } + + // test, if the node-block has a densenodes structure + if (pbf_nodes->has_dense()) { + // get a pointer to the densenodes structure + OSMPBF::DenseNodes* dense = pbf_nodes->mutable_dense(); + + // in the densenodes structure keys and vals are encoded in an intermixed + // array, individual nodes are seperated by a value of 0 (0 in the StringTable + // is always unused). String-ids of 0 are thus kept alone. + for (int i=0, l=dense->keys_vals_size(); i 0 to real string ids + auto sid = dense->keys_vals(i); + assert(sid >= 0); + assert(sid < std::numeric_limits::max()); + if (sid > 0) { + dense->set_keys_vals(i, string_table.map_string_id(static_cast(sid))); + } + } + + // test if the densenodes block has meta infos + if (dense->has_denseinfo()) { + // get a pointer to the denseinfo structure + OSMPBF::DenseInfo* denseinfo = dense->mutable_denseinfo(); + + // iterate over all username string-ids + for (int i=0, l=denseinfo->user_sid_size(); i 0 to real string ids + auto usid = denseinfo->user_sid(i); + assert(usid < std::numeric_limits::max()); + auto user_sid = string_table.map_string_id(static_cast(usid)); + + // delta encode the string-id + denseinfo->set_user_sid(i, m_delta_user_sid.update(user_sid)); + } + } + } + } + + // test, if the ways-block has been allocated + if (pbf_ways) { + // iterate over all ways, passing them to the map_common_string_ids function + for (int i=0, l=pbf_ways->ways_size(); imutable_ways(i)); + } + } + + // test, if the relations-block has been allocated + if (pbf_relations) { + // iterate over all relations + for (int i=0, l=pbf_relations->relations_size(); imutable_relations(i); + + // pass them to the map_common_string_ids function + map_common_string_ids(relation); + + // iterate over all relation members, mapping the interim string-ids + // of the role to real string ids + for (int mi=0, ml=relation->roles_sid_size(); miset_roles_sid(mi, string_table.map_string_id(relation->roles_sid(mi))); + } + } + } + } + + /** + * a helper function used in map_string_ids to map common interim string-ids of the + * user name and all tags to real string ids. + * + * TPBFObject is either OSMPBF::Node, OSMPBF::Way or OSMPBF::Relation. + */ + template + void map_common_string_ids(TPBFObject* in) { + // if the object has meta-info attached + if (in->has_info()) { + // map the interim-id of the user name to a real id + OSMPBF::Info* info = in->mutable_info(); + info->set_user_sid(string_table.map_string_id(info->user_sid())); + } + + // iterate over all tags and map the interim-ids of the key and the value to real ids + for (int i=0, l=in->keys_size(); iset_keys(i, string_table.map_string_id(in->keys(i))); + in->set_vals(i, string_table.map_string_id(in->vals(i))); + } + } + + + ///// MetaData helper ///// + + /** + * convert a double lat or lon value to an int, respecting the current blocks granularity + */ + int64_t lonlat2int(double lonlat) { + return round(lonlat * OSMPBF::lonlat_resolution / location_granularity()); + } + + /** + * convert a timestamp to an int, respecting the current blocks granularity + */ + int64_t timestamp2int(time_t timestamp) { + return round(timestamp * (static_cast(1000) / date_granularity())); + } + + /** + * helper function used in the write()-calls to apply common information from an osmium-object + * onto a pbf-object. + * + * TPBFObject is either OSMPBF::Node, OSMPBF::Way or OSMPBF::Relation. + */ + template + void apply_common_info(const osmium::OSMObject& in, TPBFObject* out) { + // set the object-id + out->set_id(in.id()); + + // iterate over all tags and set the keys and vals, recording the strings in the + // interim StringTable and storing the interim ids + for (const auto& tag : in.tags()) { + out->add_keys(string_table.record_string(tag.key())); + out->add_vals(string_table.record_string(tag.value())); + } + + if (m_should_add_metadata) { + // add an info-section to the pbf object and set the meta-info on it + OSMPBF::Info* out_info = out->mutable_info(); + if (m_add_visible) { + out_info->set_visible(in.visible()); + } + out_info->set_version(static_cast<::google::protobuf::int32>(in.version())); + out_info->set_timestamp(timestamp2int(in.timestamp())); + out_info->set_changeset(in.changeset()); + out_info->set_uid(static_cast<::google::protobuf::int32>(in.uid())); + out_info->set_user_sid(string_table.record_string(in.user())); + } + } + + + ///// High-Level Block writing ///// + + /** + * store the current pbf_header_block into a Blob and clear this struct afterwards. + */ + void store_header_block() { + if (debug && has_debug_level(1)) { + std::cerr << "storing header block" << std::endl; + } + + std::promise promise; + m_output_queue.push(promise.get_future()); + promise.set_value(serialize_blob("OSMHeader", pbf_header_block, m_use_compression)); + + pbf_header_block.Clear(); + } + + /** + * store the interim StringTable to the current pbf_primitive_block, map all interim string ids + * to real StringTable ids and then store the current pbf_primitive_block into a Blob and clear + * this struct and all related pointers and maps afterwards. + */ + void store_primitive_block() { + if (debug && has_debug_level(1)) { + std::cerr << "storing primitive block with " << primitive_block_contents << " items" << std::endl; + } + + // set the granularity + pbf_primitive_block.set_granularity(location_granularity()); + pbf_primitive_block.set_date_granularity(date_granularity()); + + // store the interim StringTable into the protobuf object + string_table.store_stringtable(pbf_primitive_block.mutable_stringtable()); + + // map all interim string ids to real ids + map_string_ids(); + + std::promise promise; + m_output_queue.push(promise.get_future()); + promise.set_value(serialize_blob("OSMData", pbf_primitive_block, m_use_compression)); + while (m_output_queue.size() > 10) { + std::this_thread::sleep_for(std::chrono::milliseconds(100)); // XXX + } + + // clear the PrimitiveBlock struct + pbf_primitive_block.Clear(); + + // clear the interim StringTable and its id map + string_table.clear(); + + // reset the delta variables + m_delta_id.clear(); + m_delta_lat.clear(); + m_delta_lon.clear(); + m_delta_timestamp.clear(); + m_delta_changeset.clear(); + m_delta_uid.clear(); + m_delta_user_sid.clear(); + + // reset the contents-counter to zero + primitive_block_contents = 0; + primitive_block_size = 0; + + // reset the node/way/relation pointers to nullptr + pbf_nodes = nullptr; + pbf_ways = nullptr; + pbf_relations = nullptr; + } + + /** + * this little function checks primitive_block_contents counter against its maximum and calls + * store_primitive_block to flush the block to the disk when it's reached. It's also responsible + * for increasing this counter. + * + * this function also checks the estimated size of the current block and calls store_primitive_block + * when the estimated size reaches buffer_fill_percent of the maximum uncompressed blob size. + */ + void check_block_contents_counter() { + if (primitive_block_contents >= max_block_contents) { + store_primitive_block(); + } else if (primitive_block_size > (static_cast(OSMPBF::max_uncompressed_blob_size) * buffer_fill_percent / 100)) { + if (debug && has_debug_level(1)) { + std::cerr << "storing primitive_block with only " << primitive_block_contents << " items, because its ByteSize (" << primitive_block_size << ") reached " << + (static_cast(primitive_block_size) / static_cast(OSMPBF::max_uncompressed_blob_size) * 100.0) << "% of the maximum blob-size" << std::endl; + } + + store_primitive_block(); + } + + ++primitive_block_contents; + } + + + ///// Block content writing ///// + + /** + * Add a node to the block. + * + * @param node The node to add. + */ + void write_node(const osmium::Node& node) { + // add a way to the group + OSMPBF::Node* pbf_node = pbf_nodes->add_nodes(); + + // copy the common meta-info from the osmium-object to the pbf-object + apply_common_info(node, pbf_node); + + // modify lat & lon to integers, respecting the block's granularity and copy + // the ints to the pbf-object + pbf_node->set_lon(lonlat2int(node.location().lon_without_check())); + pbf_node->set_lat(lonlat2int(node.location().lat_without_check())); + } + + /** + * Add a node to the block using DenseNodes. + * + * @param node The node to add. + */ + void write_dense_node(const osmium::Node& node) { + // add a DenseNodes-Section to the PrimitiveGroup + OSMPBF::DenseNodes* dense = pbf_nodes->mutable_dense(); + + // copy the id, delta encoded + dense->add_id(m_delta_id.update(node.id())); + + // copy the longitude, delta encoded + dense->add_lon(m_delta_lon.update(lonlat2int(node.location().lon_without_check()))); + + // copy the latitude, delta encoded + dense->add_lat(m_delta_lat.update(lonlat2int(node.location().lat_without_check()))); + + // in the densenodes structure keys and vals are encoded in an intermixed + // array, individual nodes are seperated by a value of 0 (0 in the StringTable + // is always unused) + // so for three nodes the keys_vals array may look like this: 3 5 2 1 0 0 8 5 + // the first node has two tags (3=>5 and 2=>1), the second node does not + // have any tags and the third node has a single tag (8=>5) + for (const auto& tag : node.tags()) { + dense->add_keys_vals(string_table.record_string(tag.key())); + dense->add_keys_vals(string_table.record_string(tag.value())); + } + dense->add_keys_vals(0); + + if (m_should_add_metadata) { + // add a DenseInfo-Section to the PrimitiveGroup + OSMPBF::DenseInfo* denseinfo = dense->mutable_denseinfo(); + + denseinfo->add_version(static_cast<::google::protobuf::int32>(node.version())); + + if (m_add_visible) { + denseinfo->add_visible(node.visible()); + } + + // copy the timestamp, delta encoded + denseinfo->add_timestamp(m_delta_timestamp.update(timestamp2int(node.timestamp()))); + + // copy the changeset, delta encoded + denseinfo->add_changeset(m_delta_changeset.update(node.changeset())); + + // copy the user id, delta encoded + denseinfo->add_uid(m_delta_uid.update(node.uid())); + + // record the user-name to the interim stringtable and copy the + // interim string-id to the pbf-object + denseinfo->add_user_sid(string_table.record_string(node.user())); + } + } + + /** + * Add a way to the block. + * + * @param way The way to add. + */ + void write_way(const osmium::Way& way) { + // add a way to the group + OSMPBF::Way* pbf_way = pbf_ways->add_ways(); + + // copy the common meta-info from the osmium-object to the pbf-object + apply_common_info(way, pbf_way); + + // last way-node-id used for delta-encoding + Delta delta_id; + + for (const auto& node_ref : way.nodes()) { + // copy the way-node-id, delta encoded + pbf_way->add_refs(delta_id.update(node_ref.ref())); + } + + // count up blob size by the size of the Way + primitive_block_size += pbf_way->ByteSize(); + } + + /** + * Add a relation to the block. + * + * @param relation The relation to add. + */ + void write_relation(const osmium::Relation& relation) { + // add a relation to the group + OSMPBF::Relation* pbf_relation = pbf_relations->add_relations(); + + // copy the common meta-info from the osmium-object to the pbf-object + apply_common_info(relation, pbf_relation); + + Delta delta_id; + + for (const auto& member : relation.members()) { + // record the relation-member role to the interim stringtable and copy the + // interim string-id to the pbf-object + pbf_relation->add_roles_sid(string_table.record_string(member.role())); + + // copy the relation-member-id, delta encoded + pbf_relation->add_memids(delta_id.update(member.ref())); + + // copy the relation-member-type, mapped to the OSMPBF enum + pbf_relation->add_types(item_type_to_osmpbf_membertype(member.type())); + } + + // count up blob size by the size of the Relation + primitive_block_size += pbf_relation->ByteSize(); + } + + // objects of this class can't be copied + PBFOutputFormat(const PBFOutputFormat&) = delete; + PBFOutputFormat& operator=(const PBFOutputFormat&) = delete; + + public: + + /** + * Create PBFOutputFormat object from File. + */ + explicit PBFOutputFormat(const osmium::io::File& file, data_queue_type& output_queue) : + OutputFormat(file, output_queue), + pbf_header_block(), + pbf_primitive_block(), + pbf_nodes(nullptr), + pbf_ways(nullptr), + pbf_relations(nullptr), + m_location_granularity(pbf_primitive_block.granularity()), + m_date_granularity(pbf_primitive_block.date_granularity()), + m_add_visible(file.has_multiple_object_versions()), + primitive_block_contents(0), + primitive_block_size(0), + string_table(), + m_delta_id(), + m_delta_lat(), + m_delta_lon(), + m_delta_timestamp(), + m_delta_changeset(), + m_delta_uid(), + m_delta_user_sid(), + debug(true) { + GOOGLE_PROTOBUF_VERIFY_VERSION; + if (file.get("pbf_dense_nodes") == "false") { + m_use_dense_nodes = false; + } + if (file.get("pbf_compression") == "none" || file.get("pbf_compression") == "false") { + m_use_compression = false; + } + if (file.get("pbf_add_metadata") == "false") { + m_should_add_metadata = false; + } + } + + void write_buffer(osmium::memory::Buffer&& buffer) override final { + osmium::apply(buffer.cbegin(), buffer.cend(), *this); + } + + + /** + * getter to access the granularity + */ + int location_granularity() const { + return m_location_granularity; + } + + /** + * setter to set the granularity + */ + PBFOutputFormat& location_granularity(int g) { + m_location_granularity = g; + return *this; + } + + + /** + * getter to access the date_granularity + */ + int date_granularity() const { + return m_date_granularity; + } + + /** + * Set date granularity. + */ + PBFOutputFormat& date_granularity(int g) { + m_date_granularity = g; + return *this; + } + + + /** + * Initialize the writing process. + * + * This initializes the header-block, sets the required-features and + * the writing-program and adds the obligatory StringTable-Index 0. + */ + void write_header(const osmium::io::Header& header) override final { + // add the schema version as required feature to the HeaderBlock + pbf_header_block.add_required_features("OsmSchema-V0.6"); + + // when the densenodes-feature is used, add DenseNodes as required feature + if (m_use_dense_nodes) { + pbf_header_block.add_required_features("DenseNodes"); + } + + // when the resulting file will carry history information, add + // HistoricalInformation as required feature + if (this->m_file.has_multiple_object_versions()) { + pbf_header_block.add_required_features("HistoricalInformation"); + } + + // set the writing program + pbf_header_block.set_writingprogram(header.get("generator")); + + if (!header.boxes().empty()) { + OSMPBF::HeaderBBox* pbf_bbox = pbf_header_block.mutable_bbox(); + osmium::Box box = header.joined_boxes(); + pbf_bbox->set_left(static_cast<::google::protobuf::int64>(box.bottom_left().lon() * OSMPBF::lonlat_resolution)); + pbf_bbox->set_bottom(static_cast<::google::protobuf::int64>(box.bottom_left().lat() * OSMPBF::lonlat_resolution)); + pbf_bbox->set_right(static_cast<::google::protobuf::int64>(box.top_right().lon() * OSMPBF::lonlat_resolution)); + pbf_bbox->set_top(static_cast<::google::protobuf::int64>(box.top_right().lat() * OSMPBF::lonlat_resolution)); + } + + 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.set_osmosis_replication_timestamp(ts); + } + + std::string osmosis_replication_sequence_number = header.get("osmosis_replication_sequence_number"); + if (!osmosis_replication_sequence_number.empty()) { + pbf_header_block.set_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.set_osmosis_replication_base_url(osmosis_replication_base_url); + } + + store_header_block(); + } + + /** + * Add a node to the pbf. + * + * A call to this method won't write the node to the file directly but + * cache it for later bulk-writing. Calling final() ensures that everything + * gets written and every file pointer is closed. + */ + void node(const osmium::Node& node) { + // first of we check the contents-counter which may flush the cached nodes to + // disk if the limit is reached. This call also increases the contents-counter + check_block_contents_counter(); + + if (debug && has_debug_level(2)) { + std::cerr << "node " << node.id() << " v" << node.version() << std::endl; + } + + // if no PrimitiveGroup for nodes has been added, add one and save the pointer + if (!pbf_nodes) { + pbf_nodes = pbf_primitive_block.add_primitivegroup(); + } + + if (m_use_dense_nodes) { + write_dense_node(node); + } else { + write_node(node); + } + } + + /** + * Add a way to the pbf. + * + * A call to this method won't write the way to the file directly but + * cache it for later bulk-writing. Calling final() ensures that everything + * gets written and every file pointer is closed. + */ + void way(const osmium::Way& way) { + // first of we check the contents-counter which may flush the cached ways to + // disk if the limit is reached. This call also increases the contents-counter + check_block_contents_counter(); + + // if no PrimitiveGroup for nodes has been added, add one and save the pointer + if (!pbf_ways) { + pbf_ways = pbf_primitive_block.add_primitivegroup(); + } + + write_way(way); + } + + /** + * Add a relation to the pbf. + * + * A call to this method won't write the way to the file directly but + * cache it for later bulk-writing. Calling final() ensures that everything + * gets written and every file pointer is closed. + */ + void relation(const osmium::Relation& relation) { + // first of we check the contents-counter which may flush the cached relations to + // disk if the limit is reached. This call also increases the contents-counter + check_block_contents_counter(); + + // if no PrimitiveGroup for relations has been added, add one and save the pointer + if (!pbf_relations) { + pbf_relations = pbf_primitive_block.add_primitivegroup(); + } + + write_relation(relation); + } + + /** + * Finalize the writing process, flush any open primitive blocks to the file and + * close the file. + */ + void close() override final { + if (debug && has_debug_level(1)) { + std::cerr << "finishing" << std::endl; + } + + // if the current block contains any elements, flush it to the protobuf + if (primitive_block_contents > 0) { + store_primitive_block(); + } + + std::promise promise; + m_output_queue.push(promise.get_future()); + promise.set_value(std::string()); + } + + }; // class PBFOutputFormat + + namespace { + + const bool registered_pbf_output = osmium::io::detail::OutputFormatFactory::instance().register_output_format(osmium::io::file_format::pbf, + [](const osmium::io::File& file, data_queue_type& output_queue) { + return new osmium::io::detail::PBFOutputFormat(file, output_queue); + }); + + } // anonymous namespace + + } // namespace detail + + } // namespace io + +} // namespace osmium + +#endif // OSMIUM_IO_DETAIL_PBF_OUTPUT_FORMAT_HPP diff --git a/ThirdParty/osmium/io/detail/pbf_stringtable.hpp b/ThirdParty/osmium/io/detail/pbf_stringtable.hpp new file mode 100644 index 000000000..b1bd5cdc1 --- /dev/null +++ b/ThirdParty/osmium/io/detail/pbf_stringtable.hpp @@ -0,0 +1,196 @@ +#ifndef OSMIUM_IO_DETAIL_PBF_STRINGTABLE_HPP +#define OSMIUM_IO_DETAIL_PBF_STRINGTABLE_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include +#include +#include +#include + +#include + +namespace osmium { + + namespace io { + + namespace detail { + + /** + * StringTable management for PBF writer + * + * All strings are stored as indexes to rows in a StringTable. The StringTable contains + * one row for each used string, so strings that are used multiple times need to be + * stored only once. The StringTable is sorted by usage-count, so the most often used + * string is stored at index 1. + */ + class StringTable { + + public: + + /// type for string IDs (interim and final) + typedef uint16_t string_id_type; + + private: + + /** + * this is the struct used to build the StringTable. It is stored as + * the value-part in the strings-map. + * + * when a new string is added to the map, its count is set to 0 and + * the interim_id is set to the current size of the map. This interim_id + * is then stored into the pbf-objects. + * + * before the PrimitiveBlock is serialized, the map is sorted by count + * and stored into the pbf-StringTable. Afterwards the interim-ids are + * mapped to the "real" id in the StringTable. + * + * this way often used strings get lower ids in the StringTable. As the + * protobuf-serializer stores numbers in variable bit-lengths, lower + * IDs means less used space in the resulting file. + */ + struct string_info { + /// number of occurrences of this string + uint16_t count; + + /// an intermediate-id + string_id_type interim_id; + }; + + /** + * Interim StringTable, storing all strings that should be written to + * the StringTable once the block is written to disk. + */ + typedef std::map string2string_info_type; + string2string_info_type m_strings; + + /** + * This vector is used to map the interim IDs to real StringTable IDs after + * writing all strings to the StringTable. + */ + typedef std::vector interim_id2id_type; + interim_id2id_type m_id2id_map; + + size_t m_size = 0; + + public: + + StringTable() { + } + + friend bool operator<(const string_info& lhs, const string_info& rhs) { + return lhs.count > rhs.count; + } + + /** + * record a string in the interim StringTable if it's missing, otherwise just increase its counter, + * return the interim-id assigned to the string. + */ + string_id_type record_string(const std::string& string) { + string_info& info = m_strings[string]; + if (info.interim_id == 0) { + ++m_size; + assert(m_size < std::numeric_limits::max()); + info.interim_id = static_cast(m_size); + } else { + info.count++; + } + return info.interim_id; + } + + /** + * Sort the interim StringTable and store it to the real protobuf StringTable. + * while storing to the real table, this function fills the id2id_map with + * pairs, mapping the interim-ids to final and real StringTable ids. + * + * Note that the m_strings table is a std::map and as such is sorted lexicographically. + * When the transformation into the sortedby multimap is done, it gets sorted by + * the count. The end result (at least with the glibc standard container/algorithm + * implementation) is that the string table is sorted first by reverse count (ie descending) + * and then by reverse lexicographic order. + */ + void store_stringtable(OSMPBF::StringTable* st) { + // add empty StringTable entry at index 0 + // StringTable index 0 is reserved as delimiter in the densenodes key/value list + // this line also ensures that there's always a valid StringTable + st->add_s(""); + + std::multimap sortedbycount; + + m_id2id_map.resize(m_size+1); + + std::transform(m_strings.begin(), m_strings.end(), + std::inserter(sortedbycount, sortedbycount.begin()), + [](const std::pair& p) { + return std::pair(p.second, p.first); + }); + + string_id_type n=0; + + for (const auto& mapping : sortedbycount) { + // add the string of the current item to the pbf StringTable + st->add_s(mapping.second); + + // store the mapping from the interim-id to the real id + m_id2id_map[mapping.first.interim_id] = ++n; + } + } + + /** + * Map from an interim ID to a real string ID. + */ + string_id_type map_string_id(const string_id_type interim_id) const { + return m_id2id_map[interim_id]; + } + + /** + * Clear the stringtable, preparing for the next block. + */ + void clear() { + m_strings.clear(); + m_id2id_map.clear(); + m_size = 0; + } + + }; // class StringTable + + } // namespace detail + + } // namespace io + +} // namespace osmium + +#endif // OSMIUM_IO_DETAIL_PBF_STRINGTABLE_HPP diff --git a/ThirdParty/osmium/io/detail/read_thread.hpp b/ThirdParty/osmium/io/detail/read_thread.hpp new file mode 100644 index 000000000..eb8461261 --- /dev/null +++ b/ThirdParty/osmium/io/detail/read_thread.hpp @@ -0,0 +1,105 @@ +#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,2014 Jochen Topf 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 +#include +#include +#include +#include +#include + +#include +#include +#include + +namespace osmium { + + namespace io { + + namespace detail { + + class ReadThread { + + osmium::thread::Queue& m_queue; + osmium::io::Decompressor* m_decompressor; + + // If this is set in the main thread, we have to wrap up at the + // next possible moment. + std::atomic& m_done; + + public: + + explicit ReadThread(osmium::thread::Queue& queue, osmium::io::Decompressor* decompressor, std::atomic& done) : + m_queue(queue), + m_decompressor(decompressor), + m_done(done) { + } + + bool operator()() { + osmium::thread::set_thread_name("_osmium_input"); + + try { + while (!m_done) { + std::string data {m_decompressor->read()}; + if (data.empty()) { + m_done = true; + } + m_queue.push(std::move(data)); + while (m_queue.size() > 10) { + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + } + } + + m_decompressor->close(); + } catch (...) { + // If there is an exception in this thread, we make sure + // to push an empty string onto the queue to signal the + // end-of-data to the reading thread so that it will not + // hang. Then we re-throw the exception. + m_queue.push(std::string()); + throw; + } + return true; + } + + }; // class ReadThread + + } // namespace detail + + } // namespace io + +} // namespace osmium + +#endif // OSMIUM_IO_DETAIL_READ_THREAD_HPP diff --git a/ThirdParty/osmium/io/detail/read_write.hpp b/ThirdParty/osmium/io/detail/read_write.hpp new file mode 100644 index 000000000..305e63b11 --- /dev/null +++ b/ThirdParty/osmium/io/detail/read_write.hpp @@ -0,0 +1,170 @@ +#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,2014 Jochen Topf 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 +#include +#include +#include +//#include +//#include +#include +#ifndef _MSC_VER +#include +#else +#include +typedef int ssize_t; +#endif + +#include + +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 open 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? + * @return 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 == "-") { + return 1; // stdout + } else { + 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 open and the stdin file descriptor (0) is returned. + * + * @return 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 + } else { + 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; + } + } + + /** + * Reads the given number of bytes into the input buffer. + * This is basically just a wrapper around read(2). + * + * @param fd File descriptor. + * @param input_buffer Buffer with data of at least size. + * @param size Number of bytes to be read. + * @return True when read was successful, false on EOF. + * @exception std::system_error On error. + */ + inline bool reliable_read(const int fd, unsigned char* input_buffer, const size_t size) { + size_t offset = 0; + while (offset < size) { + ssize_t length = ::read(fd, input_buffer + offset, size - offset); + if (length < 0) { + throw std::system_error(errno, std::system_category(), "Read failed"); + } + if (length == 0) { + return false; + } + offset += static_cast(length); + } + return true; + } + + /** + * Writes the given number of bytes from the output_buffer to the file descriptor. + * This is just a wrapper around write(2). + * + * @param fd File descriptor. + * @param output_buffer Buffer where data is written. Must be at least size bytes long. + * @param size Number of bytes to be read. + * @exception std::system_error On error. + */ + inline void reliable_write(const int fd, const unsigned char* output_buffer, const size_t size) { + size_t offset = 0; + do { + ssize_t length = ::write(fd, output_buffer + offset, size - offset); + if (length < 0) { + throw std::system_error(errno, std::system_category(), "Write failed"); + } + offset += static_cast(length); + } while (offset < size); + } + + inline void reliable_write(const int fd, const char* output_buffer, const size_t size) { + reliable_write(fd, reinterpret_cast(output_buffer), size); + } + + } // namespace detail + + } // namespace io + +} // namespace osmium + +#endif // OSMIUM_IO_DETAIL_READ_WRITE_HPP diff --git a/ThirdParty/osmium/io/detail/write_thread.hpp b/ThirdParty/osmium/io/detail/write_thread.hpp new file mode 100644 index 000000000..599851f0c --- /dev/null +++ b/ThirdParty/osmium/io/detail/write_thread.hpp @@ -0,0 +1,86 @@ +#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,2014 Jochen Topf 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 +#include + +#include +#include +#include + +namespace osmium { + + namespace io { + + namespace detail { + + class WriteThread { + + typedef osmium::io::detail::data_queue_type data_queue_type; + + data_queue_type& m_input_queue; + osmium::io::Compressor* m_compressor; + + public: + + explicit WriteThread(data_queue_type& input_queue, osmium::io::Compressor* compressor) : + m_input_queue(input_queue), + m_compressor(compressor) { + } + + bool operator()() { + osmium::thread::set_thread_name("_osmium_output"); + + std::future data_future; + std::string data; + do { + m_input_queue.wait_and_pop(data_future); + data = data_future.get(); + m_compressor->write(data); + } while (!data.empty()); + + m_compressor->close(); + return true; + } + + }; // class WriteThread + + } // namespace detail + + } // namespace io + +} // namespace osmium + +#endif // OSMIUM_IO_DETAIL_WRITE_THREAD_HPP diff --git a/ThirdParty/osmium/io/detail/xml_input_format.hpp b/ThirdParty/osmium/io/detail/xml_input_format.hpp new file mode 100644 index 000000000..461a947cd --- /dev/null +++ b/ThirdParty/osmium/io/detail/xml_input_format.hpp @@ -0,0 +1,677 @@ +#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,2014 Jochen Topf 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. + +*/ + +#define OSMIUM_LINK_WITH_LIBS_EXPAT -lexpat + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace osmium { + + struct xml_error : public io_error { + + unsigned long line; + unsigned long column; + XML_Error error_code; + std::string error_string; + + 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)) { + } + + }; // struct xml_error + + 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 { + + class File; + + namespace detail { + + /** + * Once the header is fully parsed this exception will be thrown if + * the caller is not interested in anything else except the header. + * It will break off the parsing at this point. + */ + class ParserIsDone : std::exception { + }; + + class XMLParser { + + static constexpr int buffer_size = 10 * 1000 * 1000; + + enum class context { + root, + top, + node, + way, + relation, + changeset, + ignored_node, + ignored_way, + ignored_relation, + ignored_changeset, + in_object + }; + + 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 m_node_builder; + std::unique_ptr m_way_builder; + std::unique_ptr m_relation_builder; + std::unique_ptr m_changeset_builder; + + std::unique_ptr m_tl_builder; + std::unique_ptr m_wnl_builder; + std::unique_ptr m_rml_builder; + + osmium::thread::Queue& m_input_queue; + osmium::thread::Queue& m_queue; + std::promise& m_header_promise; + + bool m_promise_fulfilled; + + osmium::osm_entity_bits::type m_read_types; + + size_t m_max_queue_size; + + std::atomic& m_done; + + public: + + explicit XMLParser(osmium::thread::Queue& input_queue, osmium::thread::Queue& queue, std::promise& header_promise, osmium::osm_entity_bits::type read_types, std::atomic& done) : + 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_tl_builder(), + m_wnl_builder(), + m_rml_builder(), + m_input_queue(input_queue), + m_queue(queue), + m_header_promise(header_promise), + m_promise_fulfilled(false), + m_read_types(read_types), + m_max_queue_size(100), + m_done(done) { + } + + /** + * The copy constructor is needed for storing XMLParser in a std::function. + * The copy will look the same as if it has been initialized with the + * same parameters as the original. Any state changes in the original will + * not be reflected in the copy. + */ + XMLParser(const XMLParser& other) : + 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_tl_builder(), + m_wnl_builder(), + m_rml_builder(), + m_input_queue(other.m_input_queue), + m_queue(other.m_queue), + m_header_promise(other.m_header_promise), + m_promise_fulfilled(false), + m_read_types(other.m_read_types), + m_max_queue_size(100), + m_done(other.m_done) { + } + + XMLParser(XMLParser&& other) = default; + + XMLParser& operator=(const XMLParser&) = delete; + + XMLParser& operator=(XMLParser&& other) = default; + + ~XMLParser() = default; + + bool operator()() { + XML_Parser parser = XML_ParserCreate(nullptr); + if (!parser) { + throw osmium::io_error("Internal error: Can not create parser"); + } + + XML_SetUserData(parser, this); + + XML_SetElementHandler(parser, start_element_wrapper, end_element_wrapper); + + try { + int done; + do { + std::string data; + m_input_queue.wait_and_pop(data); + done = data.empty(); + try { + if (XML_Parse(parser, data.data(), data.size(), done) == XML_STATUS_ERROR) { + throw osmium::xml_error(parser); + } + } catch (ParserIsDone&) { + throw; + } catch (...) { + m_queue.push(osmium::memory::Buffer()); // empty buffer to signify eof + if (!m_promise_fulfilled) { + m_promise_fulfilled = true; + m_header_promise.set_value(m_header); + } + throw; + } + } while (!done && !m_done); + header_is_done(); // make sure we'll always fulfill the promise + if (m_buffer.committed() > 0) { + m_queue.push(std::move(m_buffer)); + } + m_queue.push(osmium::memory::Buffer()); // empty buffer to signify eof + } catch (ParserIsDone&) { + // intentionally left blank + } + XML_ParserFree(parser); + return true; + } + + private: + + static void XMLCALL start_element_wrapper(void* data, const XML_Char* element, const XML_Char** attrs) { + static_cast(data)->start_element(element, attrs); + } + + static void XMLCALL end_element_wrapper(void* data, const XML_Char* element) { + static_cast(data)->end_element(element); + } + + const char* init_object(osmium::OSMObject& object, const XML_Char** attrs) { + static const char* empty = ""; + const char* user = empty; + + if (m_in_delete_section) { + object.visible(false); + } + for (int count = 0; attrs[count]; count += 2) { + if (!strcmp(attrs[count], "lon")) { + static_cast(object).location().lon(std::atof(attrs[count+1])); // XXX doesn't detect garbage after the number + } else if (!strcmp(attrs[count], "lat")) { + static_cast(object).location().lat(std::atof(attrs[count+1])); // XXX doesn't detect garbage after the number + } else if (!strcmp(attrs[count], "user")) { + user = attrs[count+1]; + } else { + object.set_attribute(attrs[count], attrs[count+1]); + } + } + + return user; + } + + void init_changeset(osmium::builder::ChangesetBuilder* builder, const XML_Char** attrs) { + static const char* empty = ""; + const char* user = empty; + osmium::Changeset& new_changeset = builder->object(); + + osmium::Location min; + osmium::Location max; + for (int count = 0; attrs[count]; count += 2) { + if (!strcmp(attrs[count], "min_lon")) { + min.lon(atof(attrs[count+1])); + } else if (!strcmp(attrs[count], "min_lat")) { + min.lat(atof(attrs[count+1])); + } else if (!strcmp(attrs[count], "max_lon")) { + max.lon(atof(attrs[count+1])); + } else if (!strcmp(attrs[count], "max_lat")) { + max.lat(atof(attrs[count+1])); + } else if (!strcmp(attrs[count], "user")) { + user = attrs[count+1]; + } else { + new_changeset.set_attribute(attrs[count], attrs[count+1]); + } + } + + new_changeset.bounds().extend(min); + new_changeset.bounds().extend(max); + + builder->add_user(user); + } + + void check_tag(osmium::builder::Builder* builder, const XML_Char* element, const XML_Char** attrs) { + if (!strcmp(element, "tag")) { + m_wnl_builder.reset(); + m_rml_builder.reset(); + + const char* key = ""; + const char* value = ""; + for (int count = 0; attrs[count]; count += 2) { + if (attrs[count][0] == 'k' && attrs[count][1] == 0) { + key = attrs[count+1]; + } + if (attrs[count][0] == 'v' && attrs[count][1] == 0) { + value = attrs[count+1]; + } + } + if (!m_tl_builder) { + m_tl_builder = std::unique_ptr(new osmium::builder::TagListBuilder(m_buffer, builder)); + } + m_tl_builder->add_tag(key, value); + } + } + + void header_is_done() { + if (!m_promise_fulfilled) { + m_header_promise.set_value(m_header); + m_promise_fulfilled = true; + if (m_read_types == osmium::osm_entity_bits::nothing) { + throw ParserIsDone(); + } + } + } + + 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.has_multiple_object_versions(true); + } + for (int count = 0; attrs[count]; count += 2) { + if (!strcmp(attrs[count], "version")) { + m_header.set("version", attrs[count+1]); + if (strcmp(attrs[count+1], "0.6")) { + throw osmium::format_version_error(attrs[count+1]); + } + } else if (!strcmp(attrs[count], "generator")) { + m_header.set("generator", attrs[count+1]); + } + } + if (m_header.get("version") == "") { + throw osmium::format_version_error(); + } + } + m_context = context::top; + break; + case context::top: + assert(!m_tl_builder); + if (!strcmp(element, "node")) { + header_is_done(); + if (m_read_types & osmium::osm_entity_bits::node) { + m_node_builder = std::unique_ptr(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")) { + header_is_done(); + if (m_read_types & osmium::osm_entity_bits::way) { + m_way_builder = std::unique_ptr(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")) { + header_is_done(); + if (m_read_types & osmium::osm_entity_bits::relation) { + m_relation_builder = std::unique_ptr(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")) { + header_is_done(); + if (m_read_types & osmium::osm_entity_bits::changeset) { + m_changeset_builder = std::unique_ptr(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; + for (int count = 0; attrs[count]; count += 2) { + if (!strcmp(attrs[count], "minlon")) { + min.lon(atof(attrs[count+1])); + } else if (!strcmp(attrs[count], "minlat")) { + min.lat(atof(attrs[count+1])); + } else if (!strcmp(attrs[count], "maxlon")) { + max.lon(atof(attrs[count+1])); + } else if (!strcmp(attrs[count], "maxlat")) { + max.lat(atof(attrs[count+1])); + } + } + 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; + check_tag(m_node_builder.get(), element, 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(new osmium::builder::WayNodeListBuilder(m_buffer, m_way_builder.get())); + } + + for (int count = 0; attrs[count]; count += 2) { + if (!strcmp(attrs[count], "ref")) { + m_wnl_builder->add_node_ref(osmium::string_to_object_id(attrs[count+1])); + } + } + } else { + check_tag(m_way_builder.get(), element, 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(new osmium::builder::RelationMemberListBuilder(m_buffer, m_relation_builder.get())); + } + + char type = 'x'; + object_id_type ref = 0; + const char* role = ""; + for (int count = 0; attrs[count]; count += 2) { + if (!strcmp(attrs[count], "type")) { + type = static_cast(attrs[count+1][0]); + } else if (!strcmp(attrs[count], "ref")) { + ref = osmium::string_to_object_id(attrs[count+1]); + } else if (!strcmp(attrs[count], "role")) { + role = static_cast(attrs[count+1]); + } + } + // XXX assert type, ref, role are set + m_rml_builder->add_member(char_to_item_type(type), ref, role); + } else { + check_tag(m_relation_builder.get(), element, attrs); + } + break; + case context::changeset: + m_last_context = context::changeset; + m_context = context::in_object; + check_tag(m_changeset_builder.get(), element, attrs); + 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")) { + header_is_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_builder.reset(); + m_buffer.commit(); + m_context = context::top; + flush_buffer(); + 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 flush_buffer() { + if (m_buffer.capacity() - m_buffer.committed() < 1000 * 1000) { + m_queue.push(std::move(m_buffer)); + osmium::memory::Buffer buffer(buffer_size); + std::swap(m_buffer, buffer); + + while (m_queue.size() > m_max_queue_size) { + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + } + } + } + + }; // XMLParser + + class XMLInputFormat : public osmium::io::detail::InputFormat { + + static constexpr size_t m_max_queue_size = 100; + + osmium::thread::Queue m_queue; + std::atomic m_done; + std::promise m_header_promise; + osmium::thread::CheckedTask m_parser_task; + + public: + + /** + * Instantiate XML Parser + * + * @param file osmium::io::File instance describing file to be read from. + * @param read_which_entities Which types of OSM entities (nodes, ways, relations, changesets) should be parsed? + * @param input_queue String queue where data is read from. + */ + explicit XMLInputFormat(const osmium::io::File& file, osmium::osm_entity_bits::type read_which_entities, osmium::thread::Queue& input_queue) : + osmium::io::detail::InputFormat(file, read_which_entities, input_queue), + m_queue(), + m_done(false), + m_header_promise(), + m_parser_task(input_queue, m_queue, m_header_promise, read_which_entities, m_done) { + } + + ~XMLInputFormat() { + m_done = true; + } + + virtual osmium::io::Header header() override final { + m_parser_task.check_for_exception(); + return m_header_promise.get_future().get(); + } + + osmium::memory::Buffer read() override { + osmium::memory::Buffer buffer; + if (!m_done || !m_queue.empty()) { + m_queue.wait_and_pop(buffer); + } + + m_parser_task.check_for_exception(); + return buffer; + } + + }; // class XMLInputFormat + + namespace { + + const bool registered_xml_input = osmium::io::detail::InputFormatFactory::instance().register_input_format(osmium::io::file_format::xml, + [](const osmium::io::File& file, osmium::osm_entity_bits::type read_which_entities, osmium::thread::Queue& input_queue) { + return new osmium::io::detail::XMLInputFormat(file, read_which_entities, input_queue); + }); + + } // anonymous namespace + + } // namespace detail + + } // namespace io + +} // namespace osmium + +#endif // OSMIUM_IO_DETAIL_XML_INPUT_FORMAT_HPP diff --git a/ThirdParty/osmium/io/detail/xml_output_format.hpp b/ThirdParty/osmium/io/detail/xml_output_format.hpp new file mode 100644 index 000000000..fc9e1e630 --- /dev/null +++ b/ThirdParty/osmium/io/detail/xml_output_format.hpp @@ -0,0 +1,482 @@ +#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,2014 Jochen Topf 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace osmium { + + namespace io { + + namespace detail { + + struct XMLWriteError {}; + + namespace { + + void xml_string(std::string& out, const char* in) { + for (; *in != '\0'; ++in) { + switch(*in) { + case '&': out += "&"; break; + case '\"': out += """; break; + case '\'': out += "'"; break; + case '<': out += "<"; break; + case '>': out += ">"; break; + default: out += *in; break; + } + } + } + + const size_t tmp_buffer_size = 100; + + template + void oprintf(std::string& out, const char* format, T value) { + char buffer[tmp_buffer_size+1]; + size_t max_size = sizeof(buffer)/sizeof(char); +#ifndef _MSC_VER + int len = snprintf(buffer, max_size, format, value); +#else + int len = _snprintf(buffer, max_size, format, value); +#endif + assert(len > 0 && static_cast(len) < max_size); + out += buffer; + } + + } // anonymous namespace + + class XMLOutputBlock : public osmium::handler::Handler { + + // operation (create, modify, delete) for osc files + enum class operation { + op_none = 0, + op_create = 1, + op_modify = 2, + op_delete = 3 + }; + + osmium::memory::Buffer m_input_buffer; + + std::string m_out; + + operation m_last_op {operation::op_none}; + + const bool m_write_visible_flag; + const bool m_write_change_ops; + + void write_spaces(int num) { + for (; num!=0; --num) { + m_out += ' '; + } + } + + void write_prefix() { + if (m_write_change_ops) { + write_spaces(4); + } else { + write_spaces(2); + } + } + + void write_meta(const osmium::OSMObject& object) { + oprintf(m_out, " id=\"%" PRId64 "\"", object.id()); + + if (object.version()) { + oprintf(m_out, " version=\"%d\"", object.version()); + } + + if (object.timestamp()) { + m_out += " timestamp=\""; + m_out += object.timestamp().to_iso(); + m_out += "\""; + } + + if (!object.user_is_anonymous()) { + oprintf(m_out, " uid=\"%d\" user=\"", object.uid()); + xml_string(m_out, object.user()); + m_out += "\""; + } + + if (object.changeset()) { + oprintf(m_out, " changeset=\"%d\"", object.changeset()); + } + + if (m_write_visible_flag) { + if (object.visible()) { + m_out += " visible=\"true\""; + } else { + m_out += " visible=\"false\""; + } + } + } + + void write_tags(const osmium::TagList& tags) { + for (const auto& tag : tags) { + write_prefix(); + m_out += " \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 += " \n"; + break; + case operation::op_modify: + m_out += " \n"; + break; + case operation::op_delete: + m_out += " \n"; + break; + } + + switch (op) { + case operation::op_none: + break; + case operation::op_create: + m_out += " \n"; + break; + case operation::op_modify: + m_out += " \n"; + break; + case operation::op_delete: + m_out += " \n"; + break; + } + + m_last_op = op; + } + + public: + + explicit XMLOutputBlock(osmium::memory::Buffer&& buffer, bool write_visible_flag, bool write_change_ops) : + m_input_buffer(std::move(buffer)), + m_write_visible_flag(write_visible_flag && !write_change_ops), + m_write_change_ops(write_change_ops) { + } + + XMLOutputBlock(const XMLOutputBlock&) = delete; + XMLOutputBlock& operator=(const XMLOutputBlock&) = delete; + + XMLOutputBlock(XMLOutputBlock&& other) = default; + XMLOutputBlock& operator=(XMLOutputBlock&& other) = default; + + std::string operator()() { + osmium::apply(m_input_buffer.cbegin(), m_input_buffer.cend(), *this); + + if (m_write_change_ops) { + open_close_op_tag(); + } + + std::string out; + std::swap(out, m_out); + return out; + } + + void node(const osmium::Node& node) { + if (m_write_change_ops) { + open_close_op_tag(node.visible() ? (node.version() == 1 ? operation::op_create : operation::op_modify) : operation::op_delete); + } + + write_prefix(); + m_out += "\n", node_ref.ref()); + } + + write_tags(way.tags()); + + write_prefix(); + m_out += "\n"; + } + + void relation(const osmium::Relation& relation) { + if (m_write_change_ops) { + open_close_op_tag(relation.visible() ? (relation.version() == 1 ? operation::op_create : operation::op_modify) : operation::op_delete); + } + + write_prefix(); + m_out += "\n"; + } + + write_tags(relation.tags()); + + write_prefix(); + m_out += "\n"; + } + + void changeset(const osmium::Changeset& changeset) { + write_prefix(); + m_out += " 10) { + std::this_thread::sleep_for(std::chrono::milliseconds(100)); // XXX + } + } + + void write_header(const osmium::io::Header& header) override final { + std::string out = "\n"; + + if (m_file.is_true("xml_change_format")) { + out += "\n"; + } else { + out += "\n"; + } + + for (const auto& box : header.boxes()) { + out += " \n", box.top_right().lat()); + } + + std::promise promise; + m_output_queue.push(promise.get_future()); + promise.set_value(std::move(out)); + } + + void close() override final { + { + std::string out; + if (m_file.is_true("xml_change_format")) { + out += "\n"; + } else { + out += "\n"; + } + + std::promise promise; + m_output_queue.push(promise.get_future()); + promise.set_value(std::move(out)); + } + + std::promise promise; + m_output_queue.push(promise.get_future()); + promise.set_value(std::string()); + } + + }; // class XMLOutputFormat + + namespace { + + const bool registered_xml_output = osmium::io::detail::OutputFormatFactory::instance().register_output_format(osmium::io::file_format::xml, + [](const osmium::io::File& file, data_queue_type& output_queue) { + return new osmium::io::detail::XMLOutputFormat(file, output_queue); + }); + + } // anonymous namespace + + } // namespace detail + + } // namespace output + +} // namespace osmium + +#endif // OSMIUM_IO_DETAIL_XML_OUTPUT_FORMAT_HPP diff --git a/ThirdParty/osmium/io/detail/zlib.hpp b/ThirdParty/osmium/io/detail/zlib.hpp new file mode 100644 index 000000000..932c04835 --- /dev/null +++ b/ThirdParty/osmium/io/detail/zlib.hpp @@ -0,0 +1,98 @@ +#ifndef OSMIUM_IO_DETAIL_ZLIB_HPP +#define OSMIUM_IO_DETAIL_ZLIB_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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. + +*/ + +#define OSMIUM_LINK_WITH_LIBS_ZLIB -lz + +#include +#include + +#include + +namespace osmium { + + namespace io { + + namespace detail { + + /** + * Compress data using zlib. + * + * @param input Data to compress. + * @return Compressed data. + */ + inline std::string zlib_compress(const std::string& input) { + unsigned long output_size = ::compressBound(input.size()); + + std::string output(output_size, '\0'); + + if (::compress(reinterpret_cast(const_cast(output.data())), + &output_size, + reinterpret_cast(input.data()), + input.size()) != Z_OK) { + throw std::runtime_error("failed to compress data"); + } + + output.resize(output_size); + + return output; + } + + /** + * Uncompress data using zlib. + * + * @param input Compressed input data. + * @param raw_size Size of uncompressed data. + * @return Uncompressed data. + */ + inline std::string zlib_uncompress(const std::string& input, unsigned long raw_size) { + std::string output(raw_size, '\0'); + + if (::uncompress(reinterpret_cast(const_cast(output.data())), + &raw_size, + reinterpret_cast(input.data()), + input.size()) != Z_OK) { + throw std::runtime_error("failed to uncompress data"); + } + + return output; + } + + } // namespace detail + + } // namespace io + +} // namespace osmium + +#endif // OSMIUM_IO_DETAIL_ZLIB_HPP diff --git a/ThirdParty/osmium/io/file.hpp b/ThirdParty/osmium/io/file.hpp new file mode 100644 index 000000000..3aa76f77a --- /dev/null +++ b/ThirdParty/osmium/io/file.hpp @@ -0,0 +1,319 @@ +#ifndef OSMIUM_IO_FILE_HPP +#define OSMIUM_IO_FILE_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include +#include + +#include +#include +#include + +namespace osmium { + + struct io_error : public std::runtime_error { + + io_error(const std::string& what) : + std::runtime_error(what) { + } + + io_error(const char* what) : + std::runtime_error(what) { + } + + }; // struct io_error + + /** + * @brief Everything related to input and output of OSM data. + */ + namespace io { + + namespace detail { + + inline std::vector split(const std::string& in, const char delim) { + std::vector 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; + + 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. + */ + explicit File(const std::string& filename = "", const std::string& format = "") : + Options(), + m_filename(filename), + m_format_string(format) { + + // stdin/stdout + if (filename == "" || filename == "-") { + m_filename = ""; + default_settings_for_stdinout(); + } + + // filename is actually a URL + std::string protocol = m_filename.substr(0, m_filename.find_first_of(':')); + if (protocol == "http" || protocol == "https") { + default_settings_for_url(); + } + + detect_format_from_suffix(m_filename); + + if (format != "") { + parse_format(format); + } + } + + File(const File& other) = default; + File& operator=(const File& other) = default; + + File(File&& other) = default; + File& operator=(File&& other) = default; + + ~File() = default; + + void parse_format(const std::string& format) { + std::vector 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 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(); + } + + 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 std::runtime_error + */ + void 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 std::runtime_error(msg); + } + } + + /** + * Set default settings for type and encoding when the filename is + * empty or "-". If you want to have a different default setting + * override this in a subclass. + */ + void default_settings_for_stdinout() { + m_file_format = file_format::unknown; + m_file_compression = file_compression::none; + } + + /** + * Set default settings for type and encoding when the filename is + * a normal file. If you want to have a different default setting + * override this in a subclass. + */ + void default_settings_for_file() { + m_file_format = file_format::unknown; + m_file_compression = file_compression::none; + } + + /** + * Set default settings for type and encoding when the filename is a URL. + * If you want to have a different default setting override this in a + * subclass. + */ + void default_settings_for_url() { + m_file_format = file_format::xml; + m_file_compression = file_compression::none; + } + + file_format format() const { + return m_file_format; + } + + File& format(file_format format) { + m_file_format = format; + return *this; + } + + file_compression compression() const { + return m_file_compression; + } + + File& compression(file_compression compression) { + m_file_compression = compression; + return *this; + } + + bool has_multiple_object_versions() const { + return m_has_multiple_object_versions; + } + + File& has_multiple_object_versions(bool value) { + 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 { + return m_filename; + } + + }; // class File + + } // namespace io + +} // namespace osmium + +#endif // OSMIUM_IO_FILE_HPP diff --git a/ThirdParty/osmium/io/file_compression.hpp b/ThirdParty/osmium/io/file_compression.hpp new file mode 100644 index 000000000..8de416d38 --- /dev/null +++ b/ThirdParty/osmium/io/file_compression.hpp @@ -0,0 +1,68 @@ +#ifndef OSMIUM_IO_FILE_COMPRESSION_HPP +#define OSMIUM_IO_FILE_COMPRESSION_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 + +namespace osmium { + + namespace io { + + enum class file_compression { + none = 0, + gzip = 1, + bzip2 = 2 + }; + + 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"; + } + } + + template + inline std::basic_ostream& operator<<(std::basic_ostream& out, const file_compression compression) { + return out << as_string(compression); + } + + } // namespace io + +} // namespace osmium + +#endif // OSMIUM_IO_FILE_COMPRESSION_HPP diff --git a/ThirdParty/osmium/io/file_format.hpp b/ThirdParty/osmium/io/file_format.hpp new file mode 100644 index 000000000..649e965bf --- /dev/null +++ b/ThirdParty/osmium/io/file_format.hpp @@ -0,0 +1,74 @@ +#ifndef OSMIUM_IO_FILE_FORMAT_HPP +#define OSMIUM_IO_FILE_FORMAT_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 + +namespace osmium { + + namespace io { + + enum class file_format { + unknown = 0, + xml = 1, + pbf = 2, + opl = 3, + json = 4 + }; + + 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"; + } + } + + template + inline std::basic_ostream& operator<<(std::basic_ostream& out, const file_format format) { + return out << as_string(format); + } + + } // namespace io + +} // namespace osmium + +#endif // OSMIUM_IO_FILE_FORMAT_HPP diff --git a/ThirdParty/osmium/io/gzip_compression.hpp b/ThirdParty/osmium/io/gzip_compression.hpp new file mode 100644 index 000000000..f9afed06c --- /dev/null +++ b/ThirdParty/osmium/io/gzip_compression.hpp @@ -0,0 +1,132 @@ +#ifndef OSMIUM_IO_GZIP_COMPRESSION_HPP +#define OSMIUM_IO_GZIP_COMPRESSION_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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. + +*/ + +#define OSMIUM_LINK_WITH_LIBS_ZLIB -lz + +#include +#include + +#include + +#include +#include + +namespace osmium { + + namespace io { + + class GzipCompressor : public Compressor { + + gzFile m_gzfile; + + public: + + explicit GzipCompressor(int fd) : + Compressor(), + m_gzfile(::gzdopen(fd, "w")) { + if (!m_gzfile) { + throw std::runtime_error("initialization of gzip compression failed"); + } + } + + ~GzipCompressor() override final { + this->close(); + } + + void write(const std::string& data) override final { + ::gzwrite(m_gzfile, data.data(), data.size()); + } + + void close() override final { + if (m_gzfile) { + ::gzclose(m_gzfile); + m_gzfile = nullptr; + } + } + + }; // class GzipCompressor + + class GzipDecompressor : public Decompressor { + + gzFile m_gzfile; + + public: + + explicit GzipDecompressor(int fd) : + Decompressor(), + m_gzfile(::gzdopen(fd, "r")) { + if (!m_gzfile) { + throw std::runtime_error("initialization of gzip compression failed"); + } + } + + ~GzipDecompressor() override final { + this->close(); + } + + std::string read() override final { + std::string buffer(osmium::io::Decompressor::input_buffer_size, '\0'); + int nread = ::gzread(m_gzfile, const_cast(buffer.data()), buffer.size()); + if (nread < 0) { + throw std::runtime_error("gzip read failed"); // XXX better error detection and reporting +// throw std::system_error(errno, std::system_category(), "Read failed"); + } + buffer.resize(static_cast(nread)); + return buffer; + } + + void close() override final { + if (m_gzfile) { + ::gzclose(m_gzfile); + m_gzfile = nullptr; + } + } + + }; // class GzipDecompressor + + namespace { + + const bool registered_gzip_compression = osmium::io::CompressionFactory::instance().register_compression(osmium::io::file_compression::gzip, + [](int fd) { return new osmium::io::GzipCompressor(fd); }, + [](int fd) { return new osmium::io::GzipDecompressor(fd); } + ); + + } // anonymous namespace + + } // namespace io + +} // namespace osmium + +#endif // OSMIUM_IO_GZIP_COMPRESSION_HPP diff --git a/ThirdParty/osmium/io/header.hpp b/ThirdParty/osmium/io/header.hpp new file mode 100644 index 000000000..c3294756a --- /dev/null +++ b/ThirdParty/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,2014 Jochen Topf 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 +#include + +#include +#include + +namespace osmium { + + namespace io { + + /** + * Meta information from the header of an OSM file. + */ + class Header : public osmium::util::Options { + + /// Bounding boxes + std::vector 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& values) : + Options(values) { + } + + Header(const Header&) = default; + Header& operator=(const Header&) = default; + + Header(Header&&) = default; + Header& operator=(Header&&) = default; + + ~Header() = default; + + std::vector& boxes() { + return m_boxes; + } + + const std::vector& boxes() const { + return m_boxes; + } + + Header& boxes(const std::vector& boxes) { + 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 { + return m_has_multiple_object_versions; + } + + Header& has_multiple_object_versions(bool h) { + m_has_multiple_object_versions = h; + return *this; + } + + }; // class Header + + } // namespace io + +} // namespace osmium + +#endif // OSMIUM_IO_HEADER_HPP diff --git a/ThirdParty/osmium/io/input_iterator.hpp b/ThirdParty/osmium/io/input_iterator.hpp new file mode 100644 index 000000000..06be82dc4 --- /dev/null +++ b/ThirdParty/osmium/io/input_iterator.hpp @@ -0,0 +1,139 @@ +#ifndef OSMIUM_IO_INPUT_ITERATOR_HPP +#define OSMIUM_IO_INPUT_ITERATOR_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include +#include + +#include +#include + +namespace osmium { + + namespace io { + + /** + * This iterator class allows you to iterate over all items from a + * source. It hides all the buffer handling and makes the contents of a + * source accessible as a normal STL input iterator. + */ + template + class InputIterator { + + static_assert(std::is_base_of::value, "TItem must derive from osmium::buffer::Item"); + + typedef typename osmium::memory::Buffer::t_iterator item_iterator; + + TSource* m_source; + std::shared_ptr m_buffer; + item_iterator m_iter {}; + + void update_buffer() { + do { + m_buffer = std::make_shared(std::move(m_source->read())); + if (!m_buffer || !*m_buffer) { // end of input + m_source = nullptr; + m_buffer.reset(); + m_iter = item_iterator(); + return; + } + m_iter = m_buffer->begin(); + } while (m_iter == m_buffer->end()); + } + + public: + + typedef std::input_iterator_tag iterator_category; + typedef TItem value_type; + typedef ptrdiff_t difference_type; + typedef TItem* pointer; + typedef TItem& reference; + + explicit InputIterator(TSource& source) : + m_source(&source) { + update_buffer(); + } + + // end iterator + InputIterator() : + m_source(nullptr) { + } + + InputIterator& operator++() { + assert(m_source); + assert(m_buffer); + assert(m_iter); + ++m_iter; + if (m_iter == m_buffer->end()) { + update_buffer(); + } + return *this; + } + + InputIterator operator++(int) { + InputIterator tmp(*this); + operator++(); + return tmp; + } + + bool operator==(const InputIterator& rhs) const { + return m_source == rhs.m_source && + m_buffer == rhs.m_buffer && + m_iter == rhs.m_iter; + } + + bool operator!=(const InputIterator& rhs) const { + return !(*this == rhs); + } + + reference operator*() const { + assert(m_iter); + return static_cast(*m_iter); + } + + pointer operator->() const { + assert(m_iter); + return &static_cast(*m_iter); + } + + }; // class InputIterator + + } // namespace io + +} // namespace osmium + +#endif // OSMIUM_IO_INPUT_ITERATOR_HPP diff --git a/ThirdParty/osmium/io/opl_output.hpp b/ThirdParty/osmium/io/opl_output.hpp new file mode 100644 index 000000000..46a12240b --- /dev/null +++ b/ThirdParty/osmium/io/opl_output.hpp @@ -0,0 +1,39 @@ +#ifndef OSMIUM_IO_OPL_OUTPUT_HPP +#define OSMIUM_IO_OPL_OUTPUT_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 // IWYU pragma: export +#include // IWYU pragma: export + +#endif // OSMIUM_IO_OPL_OUTPUT_HPP diff --git a/ThirdParty/osmium/io/output_iterator.hpp b/ThirdParty/osmium/io/output_iterator.hpp new file mode 100644 index 000000000..d83b10c54 --- /dev/null +++ b/ThirdParty/osmium/io/output_iterator.hpp @@ -0,0 +1,114 @@ +#ifndef OSMIUM_IO_OUTPUT_ITERATOR_HPP +#define OSMIUM_IO_OUTPUT_ITERATOR_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include + +#include +#include + +namespace osmium { + + namespace memory { + class Item; + } // namespace memory + + namespace io { + + template + class OutputIterator : public std::iterator { + + struct buffer_wrapper { + osmium::memory::Buffer buffer; + + buffer_wrapper(size_t buffer_size) : + buffer(buffer_size, osmium::memory::Buffer::auto_grow::no) { + } + }; + + static constexpr size_t default_buffer_size = 10 * 1024 * 1024; + + TDest& m_destination; + + std::shared_ptr m_buffer_wrapper; + + public: + + explicit OutputIterator(TDest& destination, const size_t buffer_size = default_buffer_size) : + m_destination(destination), + m_buffer_wrapper(std::make_shared(buffer_size)) { + } + + void flush() { + osmium::memory::Buffer buffer(m_buffer_wrapper->buffer.capacity(), osmium::memory::Buffer::auto_grow::no); + std::swap(m_buffer_wrapper->buffer, buffer); + m_destination(std::move(buffer)); + } + + OutputIterator& operator=(const osmium::memory::Item& item) { + try { + m_buffer_wrapper->buffer.push_back(item); + } catch (osmium::memory::BufferIsFull&) { + flush(); + m_buffer_wrapper->buffer.push_back(item); + } + return *this; + } + + OutputIterator& operator=(const osmium::DiffObject& diff) { + return this->operator=(diff.curr()); + } + + OutputIterator& operator*() { + return *this; + } + + OutputIterator& operator++() { + return *this; + } + + OutputIterator& operator++(int) { + return *this; + } + + }; // class OutputIterator + + } // namespace io + +} // namespace osmium + +#endif // OSMIUM_IO_OUTPUT_ITERATOR_HPP diff --git a/ThirdParty/osmium/io/overwrite.hpp b/ThirdParty/osmium/io/overwrite.hpp new file mode 100644 index 000000000..e6f1f968f --- /dev/null +++ b/ThirdParty/osmium/io/overwrite.hpp @@ -0,0 +1,52 @@ +#ifndef OSMIUM_IO_OVERWRITE_HPP +#define OSMIUM_IO_OVERWRITE_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2014 Jochen Topf 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. + +*/ + +namespace osmium { + + namespace io { + + /** + * Allow overwriting of existing file. + */ + enum class overwrite : bool { + no = false, + allow = true + }; + + } // namespace io + +} // namespace osmium + +#endif // OSMIUM_IO_OVERWRITE_HPP diff --git a/ThirdParty/osmium/io/pbf_input.hpp b/ThirdParty/osmium/io/pbf_input.hpp new file mode 100644 index 000000000..8426f6cf6 --- /dev/null +++ b/ThirdParty/osmium/io/pbf_input.hpp @@ -0,0 +1,39 @@ +#ifndef OSMIUM_IO_PBF_INPUT_HPP +#define OSMIUM_IO_PBF_INPUT_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 // IWYU pragma: export +#include // IWYU pragma: export + +#endif // OSMIUM_IO_PBF_INPUT_HPP diff --git a/ThirdParty/osmium/io/pbf_output.hpp b/ThirdParty/osmium/io/pbf_output.hpp new file mode 100644 index 000000000..9fd039654 --- /dev/null +++ b/ThirdParty/osmium/io/pbf_output.hpp @@ -0,0 +1,39 @@ +#ifndef OSMIUM_IO_PBF_OUTPUT_HPP +#define OSMIUM_IO_PBF_OUTPUT_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 // IWYU pragma: export +#include // IWYU pragma: export + +#endif // OSMIUM_IO_PBF_OUTPUT_HPP diff --git a/ThirdParty/osmium/io/reader.hpp b/ThirdParty/osmium/io/reader.hpp new file mode 100644 index 000000000..8acac94b5 --- /dev/null +++ b/ThirdParty/osmium/io/reader.hpp @@ -0,0 +1,281 @@ +#ifndef OSMIUM_IO_READER_HPP +#define OSMIUM_IO_READER_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include +#include +#include +#include +#include +#ifndef _WIN32 +#include +#endif +#ifndef _MSC_VER +#include +#else +#endif +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace osmium { + + namespace io { + + /** + * This is the user-facing interface for reading OSM files. Instantiate + * an object of this class with a file name or osmium::io::File object + * and then call read() on it in a loop until it returns an invalid + * Buffer. + */ + class Reader { + + osmium::io::File m_file; + osmium::osm_entity_bits::type m_read_which_entities; + std::atomic m_input_done; + int m_childpid; + + osmium::thread::Queue m_input_queue; + + std::unique_ptr m_decompressor; + osmium::thread::CheckedTask m_read_task; + + std::unique_ptr m_input; + +#ifndef _WIN32 + /** + * Fork and execute the given command in the child. + * A pipe is created between the child and the parent. + * The child writes to the pipe, the parent reads from it. + * This function never returns in the child. + * + * @param command Command to execute in the child. + * @param filename Filename to give to command as argument. + * @return File descriptor of pipe in the parent. + * @throws std::system_error if a system call fails. + */ + static int execute(const std::string& command, const std::string& filename, int* childpid) { + int pipefd[2]; + if (pipe(pipefd) < 0) { + throw std::system_error(errno, std::system_category(), "opening pipe failed"); + } + pid_t pid = fork(); + if (pid < 0) { + throw std::system_error(errno, std::system_category(), "fork failed"); + } + if (pid == 0) { // child + // close all file descriptors except one end of the pipe + for (int i=0; i < 32; ++i) { + if (i != pipefd[1]) { + ::close(i); + } + } + if (dup2(pipefd[1], 1) < 0) { // put end of pipe as stdout/stdin + exit(1); + } + + ::open("/dev/null", O_RDONLY); // stdin + ::open("/dev/null", O_WRONLY); // stderr + // hack: -g switches off globbing in curl which allows [] to be used in file names + // this is important for XAPI URLs + // in theory this execute() function could be used for other commands, but it is + // only used for curl at the moment, so this is okay. + if (::execlp(command.c_str(), command.c_str(), "-g", filename.c_str(), nullptr) < 0) { + exit(1); + } + } + // parent + *childpid = pid; + ::close(pipefd[1]); + return pipefd[0]; + } +#endif + + /** + * Open File for reading. Handles URLs or normal files. URLs + * are opened by executing the "curl" program (which must be installed) + * and reading from its output. + * + * @return File descriptor of open file or pipe. + * @throws std::system_error if a system call fails. + */ + static int open_input_file_or_url(const std::string& filename, int* childpid) { + std::string protocol = filename.substr(0, filename.find_first_of(':')); + if (protocol == "http" || protocol == "https" || protocol == "ftp" || protocol == "file") { +#ifndef _WIN32 + return execute("curl", filename, childpid); +#else + throw std::runtime_error("Reading OSM files from the network currently not supported on Windows."); +#endif + } else { + return osmium::io::detail::open_for_reading(filename); + } + } + + public: + + /** + * Create new Reader object. + * + * @param file The file we want to open. + * @param read_which_entities Which OSM entities (nodes, ways, relations, and/or changesets) + * should be read from the input file. It can speed the read up + * significantly if objects that are not needed anyway are not + * parsed. + */ + explicit Reader(const osmium::io::File& file, osmium::osm_entity_bits::type read_which_entities = osmium::osm_entity_bits::all) : + m_file(file), + m_read_which_entities(read_which_entities), + m_input_done(false), + m_childpid(0), + m_input_queue(), + m_decompressor(osmium::io::CompressionFactory::instance().create_decompressor(file.compression(), open_input_file_or_url(m_file.filename(), &m_childpid))), + m_read_task(m_input_queue, m_decompressor.get(), m_input_done), + m_input(osmium::io::detail::InputFormatFactory::instance().create_input(m_file, m_read_which_entities, m_input_queue)) { + } + + explicit Reader(const std::string& filename, osmium::osm_entity_bits::type read_types = osmium::osm_entity_bits::all) : + Reader(osmium::io::File(filename), read_types) { + } + + explicit Reader(const char* filename, osmium::osm_entity_bits::type read_types = osmium::osm_entity_bits::all) : + Reader(osmium::io::File(filename), read_types) { + } + + Reader(const Reader&) = delete; + Reader& operator=(const Reader&) = delete; + + ~Reader() { + close(); + } + + /** + * Close down the Reader. A call to this is optional, because the + * destructor of Reader will also call this. But if you don't call + * this function first, the destructor might throw an exception + * which is not good. + * + * @throws Some form of std::runtime_error when there is a problem. + */ + void close() { + // Signal to input child process that it should wrap up. + m_input_done = true; + + m_input->close(); + +#ifndef _WIN32 + if (m_childpid) { + int status; + pid_t pid = ::waitpid(m_childpid, &status, 0); +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wold-style-cast" + if (pid < 0 || !WIFEXITED(status) || WEXITSTATUS(status) != 0) { + throw std::system_error(errno, std::system_category(), "subprocess returned error"); + } +#pragma GCC diagnostic pop + m_childpid = 0; + } +#endif + + m_read_task.close(); + } + + /** + * Get the header data from the file. + */ + osmium::io::Header header() const { + return m_input->header(); + } + + /** + * Reads the next buffer from the input. An invalid buffer signals + * end-of-file. Do not call read() after the end-of-file. + * + * @returns Buffer. + * @throws Some form of std::runtime_error if there is an error. + */ + osmium::memory::Buffer read() { + // If an exception happened in the input thread, re-throw + // it in this (the main) thread. + m_read_task.check_for_exception(); + + if (m_read_which_entities == osmium::osm_entity_bits::nothing) { + // If the caller didn't want anything but the header, it will + // always get an empty buffer here. + return osmium::memory::Buffer(); + } + return m_input->read(); + } + + }; // class Reader + + /** + * Read contents of the given file into a buffer in one go. Takes + * the same arguments as any of the Reader constructors. + * + * The buffer can take up quite a lot of memory, so don't do this + * unless you are working with small OSM files and/or have lots of + * RAM. + */ + template + osmium::memory::Buffer read_file(TArgs&&... args) { + osmium::memory::Buffer buffer(1024*1024, osmium::memory::Buffer::auto_grow::yes); + + Reader reader(std::forward(args)...); + while (osmium::memory::Buffer read_buffer = reader.read()) { + buffer.add_buffer(read_buffer); + buffer.commit(); + } + + return buffer; + } + + } // namespace io + +} // namespace osmium + +#endif // OSMIUM_IO_READER_HPP diff --git a/ThirdParty/osmium/io/reader_iterator.hpp b/ThirdParty/osmium/io/reader_iterator.hpp new file mode 100644 index 000000000..ee5cc5b51 --- /dev/null +++ b/ThirdParty/osmium/io/reader_iterator.hpp @@ -0,0 +1,51 @@ +#ifndef OSMIUM_IO_READER_ITERATOR_HPP +#define OSMIUM_IO_READER_ITERATOR_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2014 Jochen Topf 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 +#include + +namespace std { + + inline osmium::io::InputIterator begin(osmium::io::Reader& reader) { + return osmium::io::InputIterator(reader); + } + + inline osmium::io::InputIterator end(osmium::io::Reader&) { + return osmium::io::InputIterator(); + } + +} // namespace std + +#endif // OSMIUM_IO_READER_ITERATOR_HPP diff --git a/ThirdParty/osmium/io/writer.hpp b/ThirdParty/osmium/io/writer.hpp new file mode 100644 index 000000000..c5ff05cf2 --- /dev/null +++ b/ThirdParty/osmium/io/writer.hpp @@ -0,0 +1,142 @@ +#ifndef OSMIUM_IO_WRITER_HPP +#define OSMIUM_IO_WRITER_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace osmium { + + namespace io { + + /** + * This is the user-facing interface for writing OSM files. Instantiate + * an object of this class with a file name or osmium::io::File object + * and optionally the data for the header and then call operator() on it + * to write Buffers. Call close() to finish up. + */ + class Writer { + + osmium::io::File m_file; + + std::unique_ptr m_output; + osmium::io::detail::data_queue_type m_output_queue; + + std::unique_ptr m_compressor; + + osmium::thread::CheckedTask m_write_task; + + public: + + /** + * The constructor of the Writer object opens a file and writes the + * header to it. + * + * @param file File (contains name and format info) to open. + * @param header Optional header data. If this is not given sensible + * defaults will be used. See the default constructor + * of osmium::io::Header for details. + * @param allow_overwrite Allow overwriting of existing file? Can be + * osmium::io::overwrite::allow or osmium::io::overwrite::no+ + * (default). + * + * @throws std::runtime_error If the file could not be opened. + * @throws std::system_error If the file could not be opened. + */ + explicit Writer(const osmium::io::File& file, const osmium::io::Header& header = osmium::io::Header(), overwrite allow_overwrite = overwrite::no) : + m_file(file), + m_output(osmium::io::detail::OutputFormatFactory::instance().create_output(m_file, m_output_queue)), + m_compressor(osmium::io::CompressionFactory::instance().create_compressor(file.compression(), osmium::io::detail::open_for_writing(m_file.filename(), allow_overwrite))), + m_write_task(m_output_queue, m_compressor.get()) { + m_output->write_header(header); + } + + explicit Writer(const std::string& filename, const osmium::io::Header& header = osmium::io::Header(), overwrite allow_overwrite = overwrite::no) : + Writer(osmium::io::File(filename), header, allow_overwrite) { + } + + explicit Writer(const char* filename, const osmium::io::Header& header = osmium::io::Header(), overwrite allow_overwrite = overwrite::no) : + Writer(osmium::io::File(filename), header, allow_overwrite) { + } + + Writer(const Writer&) = delete; + Writer& operator=(const Writer&) = delete; + + ~Writer() { + close(); + } + + /** + * Write contents of a buffer to the output file. + * + * @throws Some form of std::runtime_error when there is a problem. + */ + void operator()(osmium::memory::Buffer&& buffer) { + m_write_task.check_for_exception(); + if (buffer.committed() > 0) { + m_output->write_buffer(std::move(buffer)); + } + } + + /** + * Flush writes to output file and close it. If you do not + * call this, the destructor of Writer will also do the same + * thing. But because this call might thrown an exception, + * it is better to call close() explicitly. + * + * @throws Some form of std::runtime_error when there is a problem. + */ + void close() { + m_output->close(); + m_write_task.close(); + } + + }; // class Writer + + } // namespace io + +} // namespace osmium + +#endif // OSMIUM_IO_WRITER_HPP diff --git a/ThirdParty/osmium/io/xml_input.hpp b/ThirdParty/osmium/io/xml_input.hpp new file mode 100644 index 000000000..f33d37ee2 --- /dev/null +++ b/ThirdParty/osmium/io/xml_input.hpp @@ -0,0 +1,39 @@ +#ifndef OSMIUM_IO_XML_INPUT_HPP +#define OSMIUM_IO_XML_INPUT_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 // IWYU pragma: export +#include // IWYU pragma: export + +#endif // OSMIUM_IO_XML_INPUT_HPP diff --git a/ThirdParty/osmium/io/xml_output.hpp b/ThirdParty/osmium/io/xml_output.hpp new file mode 100644 index 000000000..d5b839f60 --- /dev/null +++ b/ThirdParty/osmium/io/xml_output.hpp @@ -0,0 +1,39 @@ +#ifndef OSMIUM_IO_XML_OUTPUT_HPP +#define OSMIUM_IO_XML_OUTPUT_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 // IWYU pragma: export +#include // IWYU pragma: export + +#endif // OSMIUM_IO_XML_OUTPUT_HPP diff --git a/ThirdParty/osmium/memory/buffer.hpp b/ThirdParty/osmium/memory/buffer.hpp new file mode 100644 index 000000000..a8a9c7441 --- /dev/null +++ b/ThirdParty/osmium/memory/buffer.hpp @@ -0,0 +1,523 @@ +#ifndef OSMIUM_MEMORY_BUFFER_HPP +#define OSMIUM_MEMORY_BUFFER_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +namespace osmium { + + /** + * @brief Memory management of items in buffers and iterators over this data. + */ + namespace memory { + + /** + * Exception thrown by the Buffer class when somebody tries to write data + * into the buffer and it doesn't fit. + */ + class BufferIsFull : public std::exception {}; + + /** + * A memory area for storing OSM objects and other items. Each item stored + * has a type and a length. See the Item class for details. + * + * Data can be added to a buffer piece by piece using reserve_space() and + * add_item(). After all data that together forms an item is added, it must + * be committed using the commit() call. Usually this is done through the + * Builder class and its derived classes. + * + * You can iterate over all items in a buffer using the iterators returned + * by begin(), end(), cbegin(), and cend(). + * + * Buffers exist in two flavours, those with external memory management and + * those with internal memory management. If you already have some memory + * with data in it (for instance read from disk), you create a Buffer with + * external memory managment. It is your job then to free the memory once + * the buffer isn't used any more. If you don't have memory already, you can + * create a Buffer object and have it manage the memory internally. It will + * dynamically allocate memory and free it again after use. + * + * By default, if a buffer gets full it will throw a BufferIsFull exception. + * You can use the set_full_callback() method to set a callback functor + * which will be called instead of throwing an exception. + */ + class Buffer { + + public: + + enum class auto_grow : bool { + yes = true, + no = false + }; + + private: + + std::vector m_memory; + unsigned char* m_data; + size_t m_capacity; + size_t m_written; + size_t m_committed; + auto_grow m_auto_grow {auto_grow::no}; + std::function m_full; + + public: + + typedef Item value_type; + + /** + * The constructor without any parameters creates a non-initialized + * buffer, ie an empty hull of a buffer that has no actual memory + * associated with it. It can be used to signify end-of-input. + */ + Buffer() : + m_memory(), + m_data(nullptr), + m_capacity(0), + m_written(0), + m_committed(0) { + } + + /** + * Constructs an externally memory-managed buffer using the given + * memory and size. + * + * @param data A pointer to some already initialized data. + * @param size The size of the initialized data. + * @exception std::invalid_argument When the size isn't a multiple of the alignment. + */ + explicit Buffer(unsigned char* data, size_t size) : + m_memory(), + m_data(data), + m_capacity(size), + m_written(size), + m_committed(size) { + if (size % align_bytes != 0) { + throw std::invalid_argument("buffer size needs to be multiple of alignment"); + } + } + + /** + * Constructs an externally memory-managed buffer with the given + * capacity that already contains 'committed' bytes of data. + * + * @param data A pointer to some (possibly initialized) data. + * @param capacity The size of the memory for this buffer. + * @param committed The size of the initialized data. If this is 0, the buffer startes out empty. + * @exception std::invalid_argument When the capacity or committed isn't a multiple of the alignment. + */ + explicit Buffer(unsigned char* data, size_t capacity, size_t committed) : + m_memory(), + m_data(data), + m_capacity(capacity), + m_written(committed), + m_committed(committed) { + if (capacity % align_bytes != 0) { + throw std::invalid_argument("buffer capacity needs to be multiple of alignment"); + } + if (committed % align_bytes != 0) { + throw std::invalid_argument("buffer parameter 'committed' needs to be multiple of alignment"); + } + } + + /** + * Create an internally memory-managed buffer with the given capacity. + * different in that it internally gets dynamic memory of the + * required size. The dynamic memory will be automatically + * freed when the Buffer is destroyed. + */ + explicit Buffer(size_t capacity, auto_grow auto_grow = auto_grow::yes) : + m_memory(capacity), + m_data(m_memory.data()), + m_capacity(capacity), + m_written(0), + m_committed(0), + m_auto_grow(auto_grow) { + if (capacity % align_bytes != 0) { + throw std::invalid_argument("buffer capacity needs to be multiple of alignment"); + } + } + + // buffers can not be copied + Buffer(const Buffer&) = delete; + Buffer& operator=(const Buffer&) = delete; + + // buffers can be moved + Buffer(Buffer&&) = default; + Buffer& operator=(Buffer&&) = default; + + ~Buffer() = default; + + /** + * Return a pointer to data inside the buffer. + */ + unsigned char* data() const { + return m_data; + } + + /** + * Returns the capacity of the buffer, ie how many bytes it can contain. + */ + size_t capacity() const { + return m_capacity; + } + + /** + * Returns the number of bytes already filled in this buffer. + */ + size_t committed() const { + return m_committed; + } + + /** + * Returns the number of bytes currently filled in this buffer that + * are not yet committed. + */ + size_t written() const { + return m_written; + } + + /** + * This tests if the current state of the buffer is aligned + * properly. Can be used for asserts. + */ + bool is_aligned() const { + return (m_written % align_bytes == 0) && (m_committed % align_bytes == 0); + } + + /** + * Set functor to be called whenever the buffer is full + * instead of throwing BufferIsFull. + */ + void set_full_callback(std::function full) { + m_full = full; + } + + /** + * Grow capacity of this buffer to the given size. + * This works only with internally memory-managed buffers. + * If the given size is not larger than the current capacity, nothing is done. + * Already written but not committed data is discarded. + * + * @param size New capacity. + */ + void grow(size_t size) { + if (m_memory.empty()) { + throw std::logic_error("Can't grow Buffer if it doesn't use internal memory management."); + } + if (m_capacity < size) { + if (size % align_bytes != 0) { + throw std::invalid_argument("buffer capacity needs to be multiple of alignment"); + } + m_memory.resize(size); + m_data = m_memory.data(); + m_capacity = size; + } + } + + /** + * Mark currently written bytes in the buffer as committed. + * + * @return Last number of committed bytes before this commit. + */ + size_t commit() { + assert(is_aligned()); + + const size_t offset = m_committed; + m_committed = m_written; + return offset; + } + + /** + * Roll back changes in buffer to last committed state. + */ + void rollback() { + m_written = m_committed; + } + + /** + * Clear the buffer. + * + * @return Number of bytes in the buffer before it was cleared. + */ + size_t clear() { + const size_t committed = m_committed; + m_written = 0; + m_committed = 0; + return committed; + } + + /** + * Get the data in the buffer at the given offset. + * + * @tparam T Type we want to the data to be interpreted as. + * @return Reference of given type pointing to the data in the buffer. + */ + template + T& get(const size_t offset) const { + return *reinterpret_cast(&m_data[offset]); + } + + /** + * Reserve space of given size in buffer and return pointer to it. + * This is the only way of adding data to the buffer. You reserve + * the space and then fill it. + * + * Note that you have to eventually call commit() to actually + * commit this data. + * + * If there isn't enough space in the buffer, one of three things + * can happen: + * + * * If you have set a callback with set_full_callback(), it is + * called. After the call returns, you must have either grown + * the buffer or cleared it by calling buffer.clear(). + * * If no callback is defined and this buffer uses internal + * memory management, the buffers capacity is grown, so that + * the new data will fit. + * * Else the BufferIsFull exception is thrown. + * + * @param size Number of bytes to reserve. + * @return Pointer to reserved space. Note that this pointer is + * only guaranteed to be valid until the next call to + * reserve_space(). + * @throw BufferIsFull Might be thrown if the buffer is full. + */ + unsigned char* reserve_space(const size_t size) { + if (m_written + size > m_capacity) { + if (m_full) { + m_full(*this); + } else if (!m_memory.empty() && (m_auto_grow == auto_grow::yes)) { + // double buffer size until there is enough space + size_t new_capacity = m_capacity * 2; + while (m_written + size > new_capacity) { + new_capacity *= 2; + } + grow(new_capacity); + } else { + throw BufferIsFull(); + } + } + unsigned char* data = &m_data[m_written]; + m_written += size; + return data; + } + + /** + * Add an item to the buffer. The size of the item is stored inside + * the item, so we know how much memory to copy. + * + * Note that you have to eventually call commit() to actually + * commit this data. + * + * @tparam T Class of the item to be copied. + * @param item Reference to the item to be copied. + * @return Reference to newly copied data in the buffer. + */ + template + T& add_item(const T& item) { + unsigned char* ptr = reserve_space(item.padded_size()); + std::memcpy(ptr, &item, item.padded_size()); + return *reinterpret_cast(ptr); + } + + /** + * Add committed contents of the given buffer to this buffer. + * + * Note that you have to eventually call commit() to actually + * commit this data. + */ + void add_buffer(const Buffer& buffer) { + unsigned char* ptr = reserve_space(buffer.committed()); + std::memcpy(ptr, buffer.data(), buffer.committed()); + } + + /** + * Add an item to the buffer. This function is provided so that + * you can use std::back_inserter. + */ + void push_back(const osmium::memory::Item& item) { + add_item(item); + commit(); + } + + /** + * These iterators can be used to iterate over all items in + * a buffer. + */ + template + using t_iterator = osmium::memory::ItemIterator; + + template + using t_const_iterator = osmium::memory::ItemIterator; + + typedef t_iterator iterator; + typedef t_const_iterator const_iterator; + + template + t_iterator begin() { + return t_iterator(m_data, m_data + m_committed); + } + + iterator begin() { + return iterator(m_data, m_data + m_committed); + } + + template + t_iterator end() { + return t_iterator(m_data + m_committed, m_data + m_committed); + } + + iterator end() { + return iterator(m_data + m_committed, m_data + m_committed); + } + + template + t_const_iterator cbegin() const { + return t_const_iterator(m_data, m_data + m_committed); + } + + const_iterator cbegin() const { + return const_iterator(m_data, m_data + m_committed); + } + + template + t_const_iterator cend() const { + return t_const_iterator(m_data + m_committed, m_data + m_committed); + } + + const_iterator cend() const { + return const_iterator(m_data + m_committed, m_data + m_committed); + } + + template + t_const_iterator begin() const { + return cbegin(); + } + + const_iterator begin() const { + return cbegin(); + } + + template + t_const_iterator end() const { + return cend(); + } + + const_iterator end() const { + return cend(); + } + + /** + * In a bool context any initialized buffer is true. + */ + explicit operator bool() const { + return m_data != nullptr; + } + + friend void swap(Buffer& lhs, Buffer& rhs) { + using std::swap; + + swap(lhs.m_memory, rhs.m_memory); + swap(lhs.m_data, rhs.m_data); + swap(lhs.m_capacity, rhs.m_capacity); + swap(lhs.m_written, rhs.m_written); + swap(lhs.m_committed, rhs.m_committed); + } + + /** + * Purge removed items from the buffer. This is done by moving all + * non-removed items forward in the buffer overwriting removed + * items and then correcting the m_written and m_committed numbers. + * + * Note that calling this function invalidates all iterators on this + * buffer and all offsets in this buffer. + * + * For every non-removed item that moves its position, the function + * 'moving_in_buffer' is called on the given callback object with + * the old and new offsets in the buffer where the object used to + * be and is now, respectively. This call can be used to update any + * indexes. + */ + template + void purge_removed(TCallbackClass* callback) { + iterator it_write = begin(); + + iterator next; + for (iterator it_read = begin(); it_read != end(); it_read = next) { + next = std::next(it_read); + if (!it_read->removed()) { + if (it_read != it_write) { + assert(it_read->data() >= data()); + assert(it_write->data() >= data()); + size_t old_offset = static_cast(it_read->data() - data()); + size_t new_offset = static_cast(it_write->data() - data()); + callback->moving_in_buffer(old_offset, new_offset); + std::memmove(it_write->data(), it_read->data(), it_read->padded_size()); + } + ++it_write; + } + } + + assert(it_write->data() >= data()); + m_written = static_cast(it_write->data() - data()); + m_committed = m_written; + } + + }; // class Buffer + + inline bool operator==(const Buffer& lhs, const Buffer& rhs) { + return lhs.data() == rhs.data() && lhs.capacity() == rhs.capacity() && lhs.committed() == rhs.committed(); + } + + inline bool operator!=(const Buffer& lhs, const Buffer& rhs) { + return ! (lhs == rhs); + } + + } // namespace memory + +} // namespace osmium + +#endif // OSMIUM_MEMORY_BUFFER_HPP diff --git a/ThirdParty/osmium/memory/collection.hpp b/ThirdParty/osmium/memory/collection.hpp new file mode 100644 index 000000000..c6256b175 --- /dev/null +++ b/ThirdParty/osmium/memory/collection.hpp @@ -0,0 +1,153 @@ +#ifndef OSMIUM_MEMORY_COLLECTION_HPP +#define OSMIUM_MEMORY_COLLECTION_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include + +#include + +namespace osmium { + + namespace memory { + + template + class CollectionIterator : public std::iterator { + + // This data_type is either 'unsigned char*' or 'const unsigned char*' depending + // on whether TMember is const. This allows this class to be used as an iterator and + // as a const_iterator. + typedef typename std::conditional::value, const unsigned char*, unsigned char*>::type data_type; + + data_type m_data; + + public: + + CollectionIterator() : + m_data(nullptr) { + } + + CollectionIterator(data_type data) : + m_data(data) { + } + + CollectionIterator& operator++() { + m_data = reinterpret_cast(m_data)->next(); + return *static_cast*>(this); + } + + CollectionIterator operator++(int) { + CollectionIterator tmp(*this); + operator++(); + return tmp; + } + + bool operator==(const CollectionIterator& rhs) const { + return m_data == rhs.m_data; + } + + bool operator!=(const CollectionIterator& rhs) const { + return m_data != rhs.m_data; + } + + unsigned char* data() const { + return m_data; + } + + TMember& operator*() const { + return *reinterpret_cast(m_data); + } + + TMember* operator->() const { + return reinterpret_cast(m_data); + } + + template + friend std::basic_ostream& operator<<(std::basic_ostream& out, const CollectionIterator& iter) { + return out << static_cast(iter.m_data); + } + + }; // class CollectionIterator + + template + class Collection : public Item { + + public: + + typedef CollectionIterator iterator; + typedef CollectionIterator const_iterator; + typedef TMember value_type; + + static constexpr osmium::item_type itemtype = TCollectionItemType; + + Collection() : + Item(sizeof(Collection), TCollectionItemType) { + } + + bool empty() const { + return sizeof(Collection) == byte_size(); + } + + iterator begin() { + return iterator(data() + sizeof(Collection)); + } + + iterator end() { + return iterator(data() + byte_size()); + } + + const_iterator cbegin() const { + return const_iterator(data() + sizeof(Collection)); + } + + const_iterator cend() const { + return const_iterator(data() + byte_size()); + } + + const_iterator begin() const { + return cbegin(); + } + + const_iterator end() const { + return cend(); + } + + }; // class Collection + + } // namespace memory + +} // namespace osmium + +#endif // OSMIUM_MEMORY_COLLECTION_HPP diff --git a/ThirdParty/osmium/memory/item.hpp b/ThirdParty/osmium/memory/item.hpp new file mode 100644 index 000000000..73e653efe --- /dev/null +++ b/ThirdParty/osmium/memory/item.hpp @@ -0,0 +1,178 @@ +#ifndef OSMIUM_MEMORY_ITEM_HPP +#define OSMIUM_MEMORY_ITEM_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include + +namespace osmium { + + // forward declaration, see osmium/osm/item_type.hpp for declaration + enum class item_type : uint16_t; + + namespace builder { + class Builder; + } + + namespace memory { + + typedef uint32_t item_size_type; + + // align datastructures to this many bytes + constexpr item_size_type align_bytes = 8; + + inline size_t padded_length(size_t length) { + return (length + align_bytes - 1) & ~(align_bytes - 1); + } + + inline item_size_type padded_length(item_size_type length) { + return (length + align_bytes - 1) & ~(align_bytes - 1); + } + + /** + * @brief Namespace for Osmium internal use + */ + namespace detail { + + /** + * This class contains only a helper method used in several + * other classes. + */ + class ItemHelper { + + protected: + + ItemHelper() = default; + + ~ItemHelper() = default; + + ItemHelper(const ItemHelper&) = default; + ItemHelper(ItemHelper&&) = default; + + ItemHelper& operator=(const ItemHelper&) = default; + ItemHelper& operator=(ItemHelper&&) = default; + + public: + + unsigned char* data() { + return reinterpret_cast(this); + } + + const unsigned char* data() const { + return reinterpret_cast(this); + } + + }; + + } // namespace detail + + class Item : public osmium::memory::detail::ItemHelper { + + item_size_type m_size; + item_type m_type; + uint16_t m_removed : 1; + uint16_t m_padding : 15; + + template + friend class CollectionIterator; + + template + friend class ItemIterator; + + friend class osmium::builder::Builder; + + unsigned char* next() { + return data() + padded_size(); + } + + const unsigned char* next() const { + return data() + padded_size(); + } + + Item& add_size(const item_size_type size) { + m_size += size; + return *this; + } + + protected: + + explicit Item(item_size_type size=0, item_type type=item_type()) : + m_size(size), + m_type(type), + m_removed(false) { + } + + Item(const Item&) = delete; + Item(Item&&) = delete; + + Item& operator=(const Item&) = delete; + Item& operator=(Item&&) = delete; + + Item& type(const item_type item_type) { + m_type = item_type; + return *this; + } + + public: + + item_size_type byte_size() const { + return m_size; + } + + item_size_type padded_size() const { + return padded_length(m_size); + } + + item_type type() const { + return m_type; + } + + bool removed() const { + return m_removed; + } + + void removed(bool removed) { + m_removed = removed; + } + + }; // class Item + + static_assert(sizeof(Item) == 8, "Class osmium::Item has wrong size!"); + static_assert(sizeof(Item) % align_bytes == 0, "Class osmium::Item has wrong size to be aligned properly!"); + + } // namespace memory + +} // namespace osmium + +#endif // OSMIUM_MEMORY_ITEM_HPP diff --git a/ThirdParty/osmium/memory/item_iterator.hpp b/ThirdParty/osmium/memory/item_iterator.hpp new file mode 100644 index 000000000..64899b333 --- /dev/null +++ b/ThirdParty/osmium/memory/item_iterator.hpp @@ -0,0 +1,181 @@ +#ifndef OSMIUM_ITEM_ITERATOR_HPP +#define OSMIUM_ITEM_ITERATOR_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2014 Jochen Topf 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 +#include +#include +#include + +#include +#include +#include + +namespace osmium { + + namespace memory { + + namespace detail { + + template + inline bool type_is_compatible(osmium::item_type) { + return true; + } + + template <> + inline bool type_is_compatible(osmium::item_type t) { + return t == osmium::item_type::node; + } + + template <> + inline bool type_is_compatible(osmium::item_type t) { + return t == osmium::item_type::way; + } + + template <> + inline bool type_is_compatible(osmium::item_type t) { + return t == osmium::item_type::relation; + } + + template <> + inline bool type_is_compatible(osmium::item_type t) { + return t == osmium::item_type::area; + } + + template <> + inline bool type_is_compatible(osmium::item_type t) { + return t == osmium::item_type::changeset; + } + + template <> + inline bool type_is_compatible(osmium::item_type t) { + return t == osmium::item_type::node || t == osmium::item_type::way || t == osmium::item_type::relation || t == osmium::item_type::area; + } + + template <> + inline bool type_is_compatible(osmium::item_type t) { + return t == osmium::item_type::node || t == osmium::item_type::way || t == osmium::item_type::relation || t == osmium::item_type::area || t == osmium::item_type::changeset; + } + + } // namespace detail + + template + class ItemIterator : public std::iterator { + + static_assert(std::is_base_of::value, "TMember must derive from osmium::memory::Item"); + + // This data_type is either 'unsigned char*' or 'const unsigned char*' depending + // on whether TMember is const. This allows this class to be used as an iterator and + // as a const_iterator. + typedef typename std::conditional::value, const unsigned char*, unsigned char*>::type data_type; + + data_type m_data; + data_type m_end; + + void advance_to_next_item_of_right_type() { + while (m_data != m_end && + !detail::type_is_compatible::type>(reinterpret_cast(m_data)->type())) { + m_data = reinterpret_cast(m_data)->next(); + } + } + + public: + + ItemIterator() : + m_data(nullptr), + m_end(nullptr) { + } + + ItemIterator(data_type data, data_type end) : + m_data(data), + m_end(end) { + advance_to_next_item_of_right_type(); + } + + ItemIterator& operator++() { + assert(m_data); + assert(m_data != m_end); + m_data = reinterpret_cast(m_data)->next(); + advance_to_next_item_of_right_type(); + return *static_cast*>(this); + } + + ItemIterator operator++(int) { + ItemIterator tmp(*this); + operator++(); + return tmp; + } + + bool operator==(const ItemIterator& rhs) const { + return m_data == rhs.m_data && m_end == rhs.m_end; + } + + bool operator!=(const ItemIterator& rhs) const { + return !(*this == rhs); + } + + unsigned char* data() const { + assert(m_data); + assert(m_data != m_end); + return m_data; + } + + TMember& operator*() const { + assert(m_data); + assert(m_data != m_end); + return *reinterpret_cast(m_data); + } + + TMember* operator->() const { + assert(m_data); + assert(m_data != m_end); + return reinterpret_cast(m_data); + } + + explicit operator bool() const { + return m_data != nullptr; + } + + template + friend std::basic_ostream& operator<<(std::basic_ostream& out, const ItemIterator& iter) { + return out << static_cast(iter.m_data); + } + + }; // class ItemIterator + + } // namespace memory + +} // namespace osmium + +#endif // OSMIUM_ITEM_ITERATOR_HPP diff --git a/ThirdParty/osmium/object_pointer_collection.hpp b/ThirdParty/osmium/object_pointer_collection.hpp new file mode 100644 index 000000000..08ea46e01 --- /dev/null +++ b/ThirdParty/osmium/object_pointer_collection.hpp @@ -0,0 +1,112 @@ +#ifndef OSMIUM_OBJECT_POINTER_COLLECTION_HPP +#define OSMIUM_OBJECT_POINTER_COLLECTION_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include + +#include + +#include +#include +#include + +// IWYU pragma: no_forward_declare osmium::OSMObject +// IWYU pragma: no_forward_declare osmium::memory::Item + +namespace osmium { + + /** + * A collection of pointers to OSM objects. The pointers can be easily + * and quickly sorted or otherwise manipulated, while the objects + * themselves or the buffers they are in, do not have to be changed. + * + * An iterator is provided that can iterate over the pointers but looks + * like it is iterating over the underlying OSM objects. + * + * This class implements the visitor pattern which makes it easy to + * populate the collection from a buffer of OSM objects: + * + * osmium::ObjectPointerCollection objects; + * osmium::memory::Buffer buffer = reader.read(); + * osmium::apply(buffer, objects); + * + */ + class ObjectPointerCollection : public osmium::handler::Handler { + + std::vector m_objects; + + public: + + typedef boost::indirect_iterator::iterator, osmium::OSMObject> iterator; + typedef boost::indirect_iterator::const_iterator, const osmium::OSMObject> const_iterator; + + ObjectPointerCollection() : + m_objects() { + } + + void osm_object(osmium::OSMObject& object) { + m_objects.push_back(&object); + } + + /** + * Sort objects according to the given order functor. + */ + template + void sort(TCompare&& compare) { + std::sort(m_objects.begin(), m_objects.end(), std::forward(compare)); + } + + iterator begin() { + return iterator { m_objects.begin() }; + } + + iterator end() { + return iterator { m_objects.end() }; + } + + const_iterator cbegin() const { + return const_iterator { m_objects.cbegin() }; + } + + const_iterator cend() const { + return const_iterator { m_objects.cend() }; + } + + }; // class ObjectPointerCollection + +} // namespace osmium + +#endif // OSMIUM_OBJECT_POINTER_COLLECTION_HPP diff --git a/ThirdParty/osmium/osm.hpp b/ThirdParty/osmium/osm.hpp new file mode 100644 index 000000000..9f5c162f0 --- /dev/null +++ b/ThirdParty/osmium/osm.hpp @@ -0,0 +1,48 @@ +#ifndef OSMIUM_OSM_HPP +#define OSMIUM_OSM_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 // IWYU pragma: export +#include // IWYU pragma: export +#include // IWYU pragma: export +#include // IWYU pragma: export +#include // IWYU pragma: export + +/** + * @brief Namespace for everything in the Osmium library. + */ +namespace osmium { +} // namespace osmium + +#endif // OSMIUM_OSM_HPP diff --git a/ThirdParty/osmium/osm/area.hpp b/ThirdParty/osmium/osm/area.hpp new file mode 100644 index 000000000..5d8233de9 --- /dev/null +++ b/ThirdParty/osmium/osm/area.hpp @@ -0,0 +1,172 @@ +#ifndef OSMIUM_OSM_AREA_HPP +#define OSMIUM_OSM_AREA_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include + +#include +#include +#include +#include +#include +#include + +namespace osmium { + + namespace builder { + template class ObjectBuilder; + } + + /** + * An outer ring of an Area. + */ + class OuterRing : public NodeRefList { + + public: + + OuterRing(): + NodeRefList() { + } + + }; // class OuterRing + + static_assert(sizeof(OuterRing) % osmium::memory::align_bytes == 0, "Class osmium::OuterRing has wrong size to be aligned properly!"); + + /** + * An inner ring of an Area. + */ + class InnerRing : public NodeRefList { + + public: + + InnerRing(): + NodeRefList() { + } + + }; // class InnerRing + + static_assert(sizeof(InnerRing) % osmium::memory::align_bytes == 0, "Class osmium::InnerRing has wrong size to be aligned properly!"); + + /** + * Convert way or (multipolygon) relation id into unique area id. + * + * @param id Id of a way or relation + * @param type Type of object (way or relation) + * @returns Area id + */ + inline osmium::object_id_type object_id_to_area_id(osmium::object_id_type id, osmium::item_type type) { + osmium::object_id_type area_id = std::abs(id) * 2; + if (type == osmium::item_type::relation) { + ++area_id; + } + return id < 0 ? -area_id : area_id; + } + + /** + * Convert area id into id of the way or relation it was created from. + * + * @param id Area id + * @returns Way or Relation id. + */ + inline osmium::object_id_type area_id_to_object_id(osmium::object_id_type id) { + return id / 2; + } + + /** + * An OSM area created out of a closed way or a multipolygon relation. + */ + class Area : public OSMObject { + + friend class osmium::builder::ObjectBuilder; + + Area() : + OSMObject(sizeof(Area), osmium::item_type::area) { + } + + public: + + static constexpr osmium::item_type itemtype = osmium::item_type::area; + + /** + * Was this area created from a way? (In contrast to areas + * created from a relation and their members.) + */ + bool from_way() const { + return (positive_id() & 0x1) == 0; + } + + /** + * Return the Id of the way or relation this area was created from. + */ + osmium::object_id_type orig_id() const { + return osmium::area_id_to_object_id(id()); + } + + /** + * Count the number of outer and inner rings of this area. + */ + std::pair num_rings() const { + std::pair counter; + + for (auto it = cbegin(); it != cend(); ++it) { + switch (it->type()) { + case osmium::item_type::outer_ring: + ++counter.first; + break; + case osmium::item_type::inner_ring: + ++counter.second; + break; + default: + break; + } + } + + return counter; + } + + /** + * Is this area a multipolygon, ie. has it more than one outer ring? + */ + bool is_multipolygon() const { + return num_rings().first > 1; + } + + }; // class Area + + static_assert(sizeof(Area) % osmium::memory::align_bytes == 0, "Class osmium::Area has wrong size to be aligned properly!"); + +} // namespace osmium + +#endif // OSMIUM_OSM_AREA_HPP diff --git a/ThirdParty/osmium/osm/box.hpp b/ThirdParty/osmium/osm/box.hpp new file mode 100644 index 000000000..fea0c70cd --- /dev/null +++ b/ThirdParty/osmium/osm/box.hpp @@ -0,0 +1,207 @@ +#ifndef OSMIUM_OSM_BOX_HPP +#define OSMIUM_OSM_BOX_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 + +#include +#include + +namespace osmium { + + /** + * Bounding box. + */ + class Box { + + osmium::Location m_bottom_left; + osmium::Location m_top_right; + + public: + + /** + * Create undefined Box. Use the extend() function + * to add actual bounds. + */ + constexpr Box() : + m_bottom_left(), + m_top_right() { + } + + Box(double minx, double miny, double maxx, double maxy) : + m_bottom_left(minx, miny), + m_top_right(maxx, maxy) { + } + + Box(const osmium::Location& bottom_left, const osmium::Location& top_right) : + m_bottom_left(bottom_left), + m_top_right(top_right) { + } + + Box(const Box&) = default; + Box(Box&&) = default; + Box& operator=(const Box&) = default; + Box& operator=(Box&&) = default; + ~Box() = default; + + /** + * Extend this bounding box by the given location. If the + * location is undefined, the bounding box is unchanged. + */ + Box& extend(const Location& location) noexcept { + if (location) { + if (m_bottom_left) { + if (location.x() < m_bottom_left.x()) { + m_bottom_left.x(location.x()); + } + if (location.x() > m_top_right.x()) { + m_top_right.x(location.x()); + } + if (location.y() < m_bottom_left.y()) { + m_bottom_left.y(location.y()); + } + if (location.y() > m_top_right.y()) { + m_top_right.y(location.y()); + } + } else { + m_bottom_left = location; + m_top_right = location; + } + } + return *this; + } + + /** + * Extend this bounding box by the given box. If the + * box is undefined, the bounding box is unchanged. + */ + Box& extend(const Box& box) noexcept { + extend(box.bottom_left()); + extend(box.top_right()); + return *this; + } + + /** + * Box are defined, ie. contains defined coordinates. + */ + explicit constexpr operator bool() const noexcept { + return static_cast(m_bottom_left); + } + + /** + * Box are valid, ie. defined and inside usual bounds + * (-180<=lon<=180, -90<=lat<=90). + */ + constexpr bool valid() const noexcept { + return bottom_left().valid() && top_right().valid(); + } + + /** + * Bottom-left location. + */ + OSMIUM_CONSTEXPR Location bottom_left() const noexcept { + return m_bottom_left; + } + + /** + * Bottom-left location. + */ + Location& bottom_left() noexcept { + return m_bottom_left; + } + + /** + * Top-right location. + */ + OSMIUM_CONSTEXPR Location top_right() const noexcept { + return m_top_right; + } + + /** + * Top-right location. + */ + Location& top_right() noexcept { + return m_top_right; + } + + /** + * Is the location inside the box? + */ + bool contains(const osmium::Location& location) const { + return location.x() >= bottom_left().x() && location.y() >= bottom_left().y() && + location.x() <= top_right().x() && location.y() <= top_right().y(); + } + + /** + * Calculate size of the box in square degrees. + * + * @throws osmium::invalid_location unless all coordinates are valid + */ + double size() const { + return (m_top_right.lon() - m_bottom_left.lon()) * + (m_top_right.lat() - m_bottom_left.lat()); + } + + }; // class Box + + /** + * Boxes are equal if both locations are equal. + */ + inline OSMIUM_CONSTEXPR bool operator==(const Box& lhs, const Box& rhs) noexcept { + return lhs.bottom_left() == rhs.bottom_left() && lhs.top_right() == rhs.top_right(); + } + + /** + * Output a box to a stream. + */ + template + inline std::basic_ostream& operator<<(std::basic_ostream& out, const osmium::Box& box) { + if (box) { + out << '(' + << box.bottom_left().lon() + << ',' + << box.bottom_left().lat() + << ',' + << box.top_right().lon() + << ',' + << box.top_right().lat() + << ')'; + } else { + out << "(undefined)"; + } + return out; + } +} // namespace osmium + +#endif // OSMIUM_OSM_BOX_HPP diff --git a/ThirdParty/osmium/osm/changeset.hpp b/ThirdParty/osmium/osm/changeset.hpp new file mode 100644 index 000000000..e04267cb1 --- /dev/null +++ b/ThirdParty/osmium/osm/changeset.hpp @@ -0,0 +1,340 @@ +#ifndef OSMIUM_OSM_CHANGESET_HPP +#define OSMIUM_OSM_CHANGESET_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace osmium { + + namespace builder { + template class ObjectBuilder; + } + + /** + * An OSM Changeset is of a group of changes made by a single user over a + * short period of time. + */ + class Changeset : public osmium::OSMEntity { + + friend class osmium::builder::ObjectBuilder; + + osmium::Timestamp m_created_at; + osmium::Timestamp m_closed_at; + osmium::Box m_bounds; + changeset_id_type m_id {0}; + num_changes_type m_num_changes {0}; + user_id_type m_uid {0}; + string_size_type m_user_size; + + Changeset() : + OSMEntity(sizeof(Changeset), osmium::item_type::changeset) { + } + + void user_size(string_size_type size) { + m_user_size = size; + } + + unsigned char* subitems_position() { + return data() + osmium::memory::padded_length(sizeof(Changeset) + m_user_size); + } + + const unsigned char* subitems_position() const { + return data() + osmium::memory::padded_length(sizeof(Changeset) + m_user_size); + } + + template + T& subitem_of_type() { + for (iterator it = begin(); it != end(); ++it) { + if (it->type() == T::itemtype) { + return reinterpret_cast(*it); + } + } + + static T subitem; + return subitem; + } + + template + const T& subitem_of_type() const { + for (const_iterator it = cbegin(); it != cend(); ++it) { + if (it->type() == T::itemtype) { + return reinterpret_cast(*it); + } + } + + static const T subitem; + return subitem; + } + + public: + + /// Get ID of this changeset + changeset_id_type id() const noexcept { + return m_id; + } + + /** + * Set ID of this changeset + * + * @return Reference to changeset to make calls chainable. + */ + Changeset& id(changeset_id_type id) noexcept { + m_id = id; + return *this; + } + + /** + * Set ID of this changeset. + * + * @return Reference to object to make calls chainable. + */ + Changeset& id(const char* id) { + return this->id(osmium::string_to_changeset_id(id)); + } + + /// Get user id. + user_id_type uid() const noexcept { + return m_uid; + } + + /** + * Set user id. + * + * @return Reference to changeset to make calls chainable. + */ + Changeset& uid(user_id_type uid) noexcept { + m_uid = uid; + return *this; + } + + /** + * Set user id. + * Sets uid to 0 (anonymous) if the given uid is smaller than 0. + * + * @return Reference to changeset to make calls chainable. + */ + Changeset& uid_from_signed(signed_user_id_type uid) noexcept { + m_uid = uid < 0 ? 0 : static_cast(uid); + return *this; + } + + /** + * Set user id. + * + * @return Reference to changeset to make calls chainable. + */ + Changeset& uid(const char* uid) { + return this->uid_from_signed(string_to_user_id(uid)); + } + + /// Is this user anonymous? + bool user_is_anonymous() const noexcept { + return m_uid == 0; + } + + /// Get timestamp when this changeset was created. + osmium::Timestamp created_at() const noexcept { + return m_created_at; + } + + /** + * Get timestamp when this changeset was closed. + * + * This will return the empty Timestamp when the + * changeset is not yet closed. + */ + osmium::Timestamp closed_at() const noexcept { + return m_closed_at; + } + + bool open() const noexcept { + return m_closed_at == osmium::Timestamp(); + } + + bool closed() const noexcept { + return !open(); + } + + /** + * Set the timestamp when this changeset was created. + * + * @param timestamp Timestamp + * @return Reference to changeset to make calls chainable. + */ + Changeset& created_at(const osmium::Timestamp timestamp) { + m_created_at = timestamp; + return *this; + } + + /** + * Set the timestamp when this changeset was closed. + * + * @param timestamp Timestamp + * @return Reference to changeset to make calls chainable. + */ + Changeset& closed_at(const osmium::Timestamp timestamp) { + m_closed_at = timestamp; + return *this; + } + + num_changes_type num_changes() const noexcept { + return m_num_changes; + } + + Changeset& num_changes(num_changes_type num_changes) noexcept { + m_num_changes = num_changes; + return *this; + } + + Changeset& num_changes(const char* num_changes) noexcept { + return this->num_changes(osmium::string_to_num_changes(num_changes)); + } + + osmium::Box& bounds() noexcept { + return m_bounds; + } + + const osmium::Box& bounds() const noexcept { + return m_bounds; + } + + /// Get user name. + const char* user() const { + return reinterpret_cast(data() + sizeof(Changeset)); + } + + /// Get the list of tags. + TagList& tags() { + return subitem_of_type(); + } + + /// Get the list of tags. + const TagList& tags() const { + return subitem_of_type(); + } + + /** + * Set named attribute. + * + * @param attr Name of the attribute (must be one of "id", "version", "changeset", "timestamp", "uid", "visible") + * @param value Value of the attribute + */ + void set_attribute(const char* attr, const char* value) { + if (!strcmp(attr, "id")) { + id(value); + } else if (!strcmp(attr, "num_changes")) { + num_changes(value); + } else if (!strcmp(attr, "created_at")) { + created_at(osmium::Timestamp(value)); + } else if (!strcmp(attr, "closed_at")) { + closed_at(osmium::Timestamp(value)); + } else if (!strcmp(attr, "uid")) { + uid(value); + } + } + + typedef osmium::memory::CollectionIterator iterator; + typedef osmium::memory::CollectionIterator const_iterator; + + iterator begin() { + return iterator(subitems_position()); + } + + iterator end() { + return iterator(data() + padded_size()); + } + + const_iterator cbegin() const { + return const_iterator(subitems_position()); + } + + const_iterator cend() const { + return const_iterator(data() + padded_size()); + } + + const_iterator begin() const { + return cbegin(); + } + + const_iterator end() const { + return cend(); + } + + }; // class Changeset + + static_assert(sizeof(Changeset) % osmium::memory::align_bytes == 0, "Class osmium::Changeset has wrong size to be aligned properly!"); + + /** + * Changesets are equal if their IDs are equal. + */ + inline bool operator==(const Changeset& lhs, const Changeset& rhs) { + return lhs.id() == rhs.id(); + } + + inline bool operator!=(const Changeset& lhs, const Changeset& rhs) { + return ! (lhs == rhs); + } + + /** + * Changesets can be ordered by id. + */ + inline bool operator<(const Changeset& lhs, const Changeset& rhs) { + return lhs.id() < rhs.id(); + } + + inline bool operator>(const Changeset& lhs, const Changeset& rhs) { + return rhs < lhs; + } + + inline bool operator<=(const Changeset& lhs, const Changeset& rhs) { + return ! (rhs < lhs); + } + + inline bool operator>=(const Changeset& lhs, const Changeset& rhs) { + return ! (lhs < rhs); + } + +} // namespace osmium + +#endif // OSMIUM_OSM_CHANGESET_HPP diff --git a/ThirdParty/osmium/osm/diff_object.hpp b/ThirdParty/osmium/osm/diff_object.hpp new file mode 100644 index 000000000..d3d9c2123 --- /dev/null +++ b/ThirdParty/osmium/osm/diff_object.hpp @@ -0,0 +1,156 @@ +#ifndef OSMIUM_OSM_DIFF_OBJECT_HPP +#define OSMIUM_OSM_DIFF_OBJECT_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include + +namespace osmium { + + class Node; + class Way; + class Relation; + + class DiffObject { + + protected: + + osmium::OSMObject* m_prev; + osmium::OSMObject* m_curr; + osmium::OSMObject* m_next; + + public: + + DiffObject() : + m_prev(nullptr), + m_curr(nullptr), + m_next(nullptr) { + } + + explicit DiffObject(osmium::OSMObject& prev, osmium::OSMObject& curr, osmium::OSMObject& next) : + m_prev(&prev), + m_curr(&curr), + m_next(&next) { + } + + DiffObject(const DiffObject& other) = default; + DiffObject& operator=(const DiffObject& other) = default; + + DiffObject(DiffObject&& other) = default; + DiffObject& operator=(DiffObject&& other) = default; + + const osmium::OSMObject& prev() const { + return *m_prev; + } + + const osmium::OSMObject& curr() const { + return *m_curr; + } + + const osmium::OSMObject& next() const { + return *m_next; + } + + bool first() const { + return m_prev == m_curr; + } + + bool last() const { + return m_curr == m_next; + } + + osmium::item_type type() const { + return m_curr->type(); + } + + osmium::object_id_type id() const { + return m_curr->id(); + } + + osmium::object_version_type version() const { + return m_curr->version(); + } + + osmium::changeset_id_type changeset() const { + return m_curr->changeset(); + } + + const osmium::Timestamp start_time() const { + return m_curr->timestamp(); + } + + const osmium::Timestamp end_time() const { + return last() ? osmium::Timestamp() : m_next->timestamp(); + } + + }; // class DiffObject + + template + class DiffObjectDerived : public DiffObject { + + public: + + DiffObjectDerived(T& prev, T& curr, T& next) : + DiffObject(prev, curr, next) { + } + + DiffObjectDerived(const DiffObjectDerived& other) = default; + DiffObjectDerived& operator=(const DiffObjectDerived& other) = default; + + DiffObjectDerived(DiffObjectDerived&& other) = default; + DiffObjectDerived& operator=(DiffObjectDerived&& other) = default; + + const T& prev() const { + return *static_cast(m_prev); + } + + const T& curr() const { + return *static_cast(m_curr); + } + + const T& next() const { + return *static_cast(m_next); + } + + }; // class DiffObjectDerived + + typedef DiffObjectDerived DiffNode; + typedef DiffObjectDerived DiffWay; + typedef DiffObjectDerived DiffRelation; + +} // namespace osmium + +#endif // OSMIUM_OSM_DIFF_OBJECT_HPP diff --git a/ThirdParty/osmium/osm/entity.hpp b/ThirdParty/osmium/osm/entity.hpp new file mode 100644 index 000000000..9d068f587 --- /dev/null +++ b/ThirdParty/osmium/osm/entity.hpp @@ -0,0 +1,55 @@ +#ifndef OSMIUM_OSM_ENTITY_HPP +#define OSMIUM_OSM_ENTITY_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 + +namespace osmium { + + /** + * OSMEntity is the parent class for the OSMObject class and the Changeset class. + */ + class OSMEntity : public osmium::memory::Item { + + public: + + explicit OSMEntity(osmium::memory::item_size_type size, osmium::item_type type) : + Item(size, type) { + } + + }; // class OSMEntity + +} // namespace osmium + +#endif // OSMIUM_OSM_ENTITY_HPP diff --git a/ThirdParty/osmium/osm/entity_bits.hpp b/ThirdParty/osmium/osm/entity_bits.hpp new file mode 100644 index 000000000..d6e4a8b75 --- /dev/null +++ b/ThirdParty/osmium/osm/entity_bits.hpp @@ -0,0 +1,93 @@ +#ifndef OSMIUM_OSM_ENTITY_BITS_HPP +#define OSMIUM_OSM_ENTITY_BITS_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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. + +*/ + +namespace osmium { + + /** + * @brief Bitfield for OSM entity types. + */ + namespace osm_entity_bits { + + /** + * Describes zero or more OSM entities. + * + * Usage: + * + * @code{.cpp} + * osmium::osm_entity_bits::type entities = osmium::osm_entity_bits::node | osmium::osm_entity_bits::way; + * + * entities |= osmium::osm_entity_bits::relation; + * + * assert(entities & osmium::osm_entity_bits::object); + * + * assert(! (entities & osmium::osm_entity_bits::changeset)); + * @endcode + */ + enum type : unsigned char { + + nothing = 0x00, + node = 0x01, + way = 0x02, + relation = 0x04, + area = 0x08, + object = 0x0f, ///< node, way, relation, or area object + changeset = 0x10, + all = 0x1f ///< object or changeset + + }; // enum type + + inline type operator|(const type lhs, const type rhs) { + return static_cast(static_cast(lhs) | static_cast (rhs)); + } + + inline type& operator|=(type& lhs, const type rhs) { + lhs = lhs | rhs; + return lhs; + } + + inline type operator&(const type lhs, const type rhs) { + return static_cast(static_cast(lhs) & static_cast (rhs)); + } + + inline type operator&=(type& lhs, const type rhs) { + lhs = lhs & rhs; + return lhs; + } + + } // namespace osm_entity_bits + +} // namespace osmium + +#endif // OSMIUM_OSM_ENTITY_BITS_HPP diff --git a/ThirdParty/osmium/osm/item_type.hpp b/ThirdParty/osmium/osm/item_type.hpp new file mode 100644 index 000000000..90075d331 --- /dev/null +++ b/ThirdParty/osmium/osm/item_type.hpp @@ -0,0 +1,163 @@ +#ifndef OSMIUM_OSM_ITEM_TYPE_HPP +#define OSMIUM_OSM_ITEM_TYPE_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 // IWYU pragma: keep +#include +#include + +namespace osmium { + + enum class item_type : uint16_t { + + undefined = 0x00, + node = 0x01, + way = 0x02, + relation = 0x03, + area = 0x04, + changeset = 0x05, + tag_list = 0x11, + way_node_list = 0x12, + relation_member_list = 0x13, + relation_member_list_with_full_members = 0x23, + outer_ring = 0x40, + inner_ring = 0x41 + + }; // enum class item_type + + inline item_type char_to_item_type(const char c) { + switch (c) { + case 'X': + return item_type::undefined; + case 'n': + return item_type::node; + case 'w': + return item_type::way; + case 'r': + return item_type::relation; + case 'a': + return item_type::area; + case 'c': + return item_type::changeset; + case 'T': + return item_type::tag_list; + case 'N': + return item_type::way_node_list; + case 'M': + return item_type::relation_member_list; + case 'F': + return item_type::relation_member_list_with_full_members; + case 'O': + return item_type::outer_ring; + case 'I': + return item_type::inner_ring; + default: + return item_type::undefined; + } + } + + inline char item_type_to_char(const item_type type) { + switch (type) { + case item_type::undefined: + return 'X'; + case item_type::node: + return 'n'; + case item_type::way: + return 'w'; + case item_type::relation: + return 'r'; + case item_type::area: + return 'a'; + case item_type::changeset: + return 'c'; + case item_type::tag_list: + return 'T'; + case item_type::way_node_list: + return 'N'; + case item_type::relation_member_list: + return 'M'; + case item_type::relation_member_list_with_full_members: + return 'F'; + case item_type::outer_ring: + return 'O'; + case item_type::inner_ring: + return 'I'; + } + } + + inline const char* item_type_to_name(const item_type type) { + switch (type) { + case item_type::undefined: + return "undefined"; + case item_type::node: + return "node"; + case item_type::way: + return "way"; + case item_type::relation: + return "relation"; + case item_type::area: + return "area"; + case item_type::changeset: + return "changeset"; + case item_type::tag_list: + return "tag_list"; + case item_type::way_node_list: + return "way_node_list"; + case item_type::relation_member_list: + return "relation_member_list"; + case item_type::relation_member_list_with_full_members: + return "relation_member_list_with_full_members"; + case item_type::outer_ring: + return "outer_ring"; + case item_type::inner_ring: + return "inner_ring"; + } + } + + template + inline std::basic_ostream& operator<<(std::basic_ostream& out, const item_type item_type) { + return out << item_type_to_char(item_type); + } + + struct unknown_type : public std::runtime_error { + + unknown_type() : + std::runtime_error("unknown item type") { + } + + }; // struct unknown_type + +} // namespace osmium + +#endif // OSMIUM_OSM_ITEM_TYPE_HPP diff --git a/ThirdParty/osmium/osm/location.hpp b/ThirdParty/osmium/osm/location.hpp new file mode 100644 index 000000000..8884583ad --- /dev/null +++ b/ThirdParty/osmium/osm/location.hpp @@ -0,0 +1,311 @@ +#ifndef OSMIUM_OSM_LOCATION_HPP +#define OSMIUM_OSM_LOCATION_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include + +namespace osmium { + + /** + * Exception signaling an invalid location, ie a location + * outside the -180 to 180 and -90 to 90 degree range. + */ + struct invalid_location : public std::range_error { + + invalid_location(const std::string& what) : + std::range_error(what) { + } + + invalid_location(const char* what) : + std::range_error(what) { + } + + }; // struct invalid_location + + /** + * Locations define a place on earth. + * + * Locations are stored in 32 bit integers for the x and y + * coordinates, respectively. This gives you an accuracy of a few + * centimeters, good enough for OSM use. (The main OSM database + * uses the same scheme.) + * + * An undefined Location can be created by calling the constructor + * without parameters. + * + * Coordinates are never checked on whether they are inside bounds. + * Call valid() to check this. + */ + class Location { + + int32_t m_x; + int32_t m_y; + + public: + + /// this value is used for a coordinate to mark it as undefined + // MSVC doesn't declare std::numeric_limits::max() as + // constexpr, so we hard code this for the time being. + // static constexpr int32_t undefined_coordinate = std::numeric_limits::max(); + static constexpr int32_t undefined_coordinate = 2147483647; + + static constexpr int coordinate_precision = 10000000; + + static int32_t double_to_fix(const double c) noexcept { + return static_cast(std::round(c * coordinate_precision)); + } + + static OSMIUM_CONSTEXPR double fix_to_double(const int32_t c) noexcept { + return static_cast(c) / coordinate_precision; + } + + /** + * Create undefined Location. + */ + explicit constexpr Location() : + m_x(undefined_coordinate), + m_y(undefined_coordinate) { + } + + /** + * Create Location with given x and y coordinates. + * Note that these coordinates are coordinate_precision + * times larger than the real coordinates. + */ + constexpr Location(const int32_t x, const int32_t y) : + m_x(x), + m_y(y) { + } + + /** + * Create Location with given x and y coordinates. + * Note that these coordinates are coordinate_precision + * times larger than the real coordinates. + */ + constexpr Location(const int64_t x, const int64_t y) : + m_x(static_cast(x)), + m_y(static_cast(y)) { + } + + /** + * Create Location with given longitude and latitude. + */ + Location(const double lon, const double lat) : + m_x(double_to_fix(lon)), + m_y(double_to_fix(lat)) { + } + + Location(const Location&) = default; + Location(Location&&) = default; + Location& operator=(const Location&) = default; + Location& operator=(Location&&) = default; + ~Location() = default; + + /** + * Check whether the coordinates of this location + * are defined. + */ + explicit constexpr operator bool() const noexcept { + return m_x != undefined_coordinate && m_y != undefined_coordinate; + } + + /** + * Check whether the coordinates are inside the + * usual bounds (-180<=lon<=180, -90<=lat<=90). + */ + constexpr bool valid() const noexcept { + return m_x >= -180 * coordinate_precision + && m_x <= 180 * coordinate_precision + && m_y >= -90 * coordinate_precision + && m_y <= 90 * coordinate_precision; + } + + constexpr int32_t x() const noexcept { + return m_x; + } + + constexpr int32_t y() const noexcept { + return m_y; + } + + Location& x(const int32_t x) noexcept { + m_x = x; + return *this; + } + + Location& y(const int32_t y) noexcept { + m_y = y; + return *this; + } + + /** + * Get longitude. + * + * @throws invalid_location if the location is invalid + */ + double lon() const { + if (!valid()) { + throw osmium::invalid_location("invalid location"); + } + return fix_to_double(m_x); + } + + /** + * Get longitude without checking the validity. + */ + double lon_without_check() const { + return fix_to_double(m_x); + } + + /** + * Get latitude. + * + * @throws invalid_location if the location is invalid + */ + double lat() const { + if (!valid()) { + throw osmium::invalid_location("invalid location"); + } + return fix_to_double(m_y); + } + + /** + * Get latitude without checking the validity. + */ + double lat_without_check() const { + return fix_to_double(m_y); + } + + Location& lon(double lon) noexcept { + m_x = double_to_fix(lon); + return *this; + } + + Location& lat(double lat) noexcept { + m_y = double_to_fix(lat); + return *this; + } + + static constexpr int coordinate_length = + 1 + /* sign */ + 3 + /* before . */ + 1 + /* . */ + 7 + /* after . */ + 1; /* null byte */ + + template + static T coordinate2string(T iterator, double value) { + char buffer[coordinate_length]; + +#ifndef _MSC_VER + int len = snprintf(buffer, coordinate_length, "%.7f", value); +#else + int len = _snprintf(buffer, coordinate_length, "%.7f", value); +#endif + assert(len > 0 && len < coordinate_length); + while (buffer[len-1] == '0') --len; + if (buffer[len-1] == '.') --len; + + return std::copy_n(buffer, len, iterator); + } + + template + T as_string(T iterator, const char separator) const { + iterator = coordinate2string(iterator, lon()); + *iterator++ = separator; + return coordinate2string(iterator, lat()); + } + + }; // class Location + + /** + * Locations are equal if both coordinates are equal. + */ + inline OSMIUM_CONSTEXPR bool operator==(const Location& lhs, const Location& rhs) noexcept { + return lhs.x() == rhs.x() && lhs.y() == rhs.y(); + } + + inline OSMIUM_CONSTEXPR bool operator!=(const Location& lhs, const Location& rhs) { + return ! (lhs == rhs); + } + + /** + * Compare two locations by comparing first the x and then + * the y coordinate. If either of the locations is + * undefined the result is undefined. + */ + inline OSMIUM_CONSTEXPR bool operator<(const Location& lhs, const Location& rhs) noexcept { + return (lhs.x() == rhs.x() && lhs.y() < rhs.y()) || lhs.x() < rhs.x(); + } + + inline OSMIUM_CONSTEXPR bool operator>(const Location& lhs, const Location& rhs) { + return rhs < lhs; + } + + inline OSMIUM_CONSTEXPR bool operator<=(const Location& lhs, const Location& rhs) { + return ! (rhs < lhs); + } + + inline OSMIUM_CONSTEXPR bool operator>=(const Location& lhs, const Location& rhs) { + return ! (lhs < rhs); + } + + /** + * Output a location to a stream. + */ + template + inline std::basic_ostream& operator<<(std::basic_ostream& out, const osmium::Location& location) { + if (location) { + out << '(' << location.lon() << ',' << location.lat() << ')'; + } else { + out << "(undefined,undefined)"; + } + return out; + } + +} // namespace osmium + +#endif // OSMIUM_OSM_LOCATION_HPP diff --git a/ThirdParty/osmium/osm/node.hpp b/ThirdParty/osmium/osm/node.hpp new file mode 100644 index 000000000..e1bc2d0eb --- /dev/null +++ b/ThirdParty/osmium/osm/node.hpp @@ -0,0 +1,80 @@ +#ifndef OSMIUM_OSM_NODE_HPP +#define OSMIUM_OSM_NODE_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include + +namespace osmium { + + namespace builder { + template class ObjectBuilder; + } + + class Node : public OSMObject { + + friend class osmium::builder::ObjectBuilder; + + osmium::Location m_location; + + Node() : + OSMObject(sizeof(Node), osmium::item_type::node) { + } + + public: + + static constexpr osmium::item_type itemtype = osmium::item_type::node; + + const osmium::Location location() const { + return m_location; + } + + osmium::Location& location() { + return m_location; + } + + Node& location(const osmium::Location& location) { + m_location = location; + return *this; + } + + }; // class Node + + static_assert(sizeof(Node) % osmium::memory::align_bytes == 0, "Class osmium::Node has wrong size to be aligned properly!"); + +} // namespace osmium + +#endif // OSMIUM_OSM_NODE_HPP diff --git a/ThirdParty/osmium/osm/node_ref.hpp b/ThirdParty/osmium/osm/node_ref.hpp new file mode 100644 index 000000000..5e10b0ab6 --- /dev/null +++ b/ThirdParty/osmium/osm/node_ref.hpp @@ -0,0 +1,152 @@ +#ifndef OSMIUM_OSM_NODE_REF_HPP +#define OSMIUM_OSM_NODE_REF_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include + +#include +#include +#include +#include + +namespace osmium { + + /** + * This reference to a node contains a node ID and a (possibly empty) + * location. + */ + class NodeRef : public osmium::memory::detail::ItemHelper { + + osmium::object_id_type m_ref; + osmium::Location m_location; + + public: + + NodeRef(const osmium::object_id_type ref=0, const osmium::Location& location=Location()) : + m_ref(ref), + m_location(location) { + } + + osmium::object_id_type ref() const { + return m_ref; + } + + osmium::unsigned_object_id_type positive_ref() const { + return static_cast(std::abs(m_ref)); + } + + osmium::Location location() const { + return m_location; + } + + double lon() const { + return m_location.lon(); + } + + double lat() const { + return m_location.lat(); + } + + void location(const osmium::Location& location) { + m_location = location; + } + + }; // class NodeRef + + inline bool operator==(const NodeRef& lhs, const NodeRef& rhs) { + return lhs.ref() == rhs.ref(); + } + + inline bool operator!=(const NodeRef& lhs, const NodeRef& rhs) { + return ! (lhs == rhs); + } + + inline bool operator<(const NodeRef& lhs, const NodeRef& rhs) { + return lhs.ref() < rhs.ref(); + } + + inline bool operator>(const NodeRef& lhs, const NodeRef& rhs) { + return rhs < lhs; + } + + inline bool operator<=(const NodeRef& lhs, const NodeRef& rhs) { + return ! (rhs < lhs); + } + + inline bool operator>=(const NodeRef& lhs, const NodeRef& rhs) { + return ! (lhs < rhs); + } + + /** + * Output a NodeRef to a stream. + */ + template + inline std::basic_ostream& operator<<(std::basic_ostream& out, const osmium::NodeRef& nr) { + return out << "<" << nr.ref() << " " << nr.location() << ">"; + } + + /** + * Functor to compare NodeRefs by Location instead of id. + */ + struct location_equal { + + bool operator()(const NodeRef& lhs, const NodeRef& rhs) const { + return lhs.location() == rhs.location(); + } + + typedef NodeRef first_argument_type; + typedef NodeRef second_argument_type; + typedef bool result_type; + + }; // struct location_equal + + /** + * Functor to compare NodeRefs by Location instead of id. + */ + struct location_less { + + bool operator()(const NodeRef& lhs, const NodeRef& rhs) const { + return lhs.location() < rhs.location(); + } + + typedef NodeRef first_argument_type; + typedef NodeRef second_argument_type; + typedef bool result_type; + + }; // struct location_less + +} // namespace osmium + +#endif // OSMIUM_OSM_NODE_REF_HPP diff --git a/ThirdParty/osmium/osm/node_ref_list.hpp b/ThirdParty/osmium/osm/node_ref_list.hpp new file mode 100644 index 000000000..5ece86b06 --- /dev/null +++ b/ThirdParty/osmium/osm/node_ref_list.hpp @@ -0,0 +1,135 @@ +#ifndef OSMIUM_OSM_NODE_REF_LIST_HPP +#define OSMIUM_OSM_NODE_REF_LIST_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include + +#include +#include +#include + +namespace osmium { + + /** + * A vector of NodeRef objects. Usually this is not instatiated directly, + * but one of its subclasses are used. + */ + template + class NodeRefList : public osmium::memory::Item { + + public: + + static constexpr osmium::item_type itemtype = TItemType; + + NodeRefList(): + osmium::memory::Item(sizeof(NodeRefList), TItemType) { + } + + bool empty() const { + return sizeof(NodeRefList) == byte_size(); + } + + size_t size() const noexcept { + assert((osmium::memory::Item::byte_size() - sizeof(NodeRefList)) % sizeof(NodeRef) == 0); + return (osmium::memory::Item::byte_size() - sizeof(NodeRefList)) / sizeof(NodeRef); + } + + const NodeRef& operator[](size_t n) const { + const NodeRef* node_ref = &*(this->cbegin()); + return node_ref[n]; + } + + const NodeRef& front() const { + return operator[](0); + } + + const NodeRef& back() const { + return operator[](size()-1); + } + + bool is_closed() const { + return front().ref() == back().ref(); + } + + bool ends_have_same_id() const { + return front().ref() == back().ref(); + } + + bool ends_have_same_location() const { + return front().location() == back().location(); + } + + typedef NodeRef* iterator; + typedef const NodeRef* const_iterator; + typedef std::reverse_iterator const_reverse_iterator; + + iterator begin() { + return iterator(data() + sizeof(NodeRefList)); + } + + iterator end() { + return iterator(data() + byte_size()); + } + + const_iterator cbegin() const { + return const_iterator(data() + sizeof(NodeRefList)); + } + + const_iterator cend() const { + return const_iterator(data() + byte_size()); + } + + const_iterator begin() const { + return cbegin(); + } + + const_iterator end() const { + return cend(); + } + + const_reverse_iterator crbegin() const { + return const_reverse_iterator(this->cend()); + } + + const_reverse_iterator crend() const { + return const_reverse_iterator(this->cbegin()); + } + + }; // class NodeRefList + +} // namespace osmium + +#endif // OSMIUM_OSM_NODE_REF_LIST_HPP diff --git a/ThirdParty/osmium/osm/object.hpp b/ThirdParty/osmium/osm/object.hpp new file mode 100644 index 000000000..1ef379892 --- /dev/null +++ b/ThirdParty/osmium/osm/object.hpp @@ -0,0 +1,429 @@ +#ifndef OSMIUM_OSM_OBJECT_HPP +#define OSMIUM_OSM_OBJECT_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace osmium { + + /** + * OSMObject (Node, Way, Relation, or Area). + */ + class OSMObject : public osmium::OSMEntity { + + object_id_type m_id; + bool m_deleted : 1; + object_version_type m_version : 31; + osmium::Timestamp m_timestamp; + user_id_type m_uid; + changeset_id_type m_changeset; + + size_t sizeof_object() const { + return sizeof(OSMObject) + (type() == item_type::node ? sizeof(osmium::Location) : 0) + sizeof(string_size_type); + } + + unsigned char* user_position() { + return data() + sizeof_object() - sizeof(string_size_type); + } + + const unsigned char* user_position() const { + return data() + sizeof_object() - sizeof(string_size_type); + } + + string_size_type user_size() const { + return *reinterpret_cast(user_position()); + } + + unsigned char* subitems_position() { + return data() + osmium::memory::padded_length(sizeof_object() + user_size()); + } + + const unsigned char* subitems_position() const { + return data() + osmium::memory::padded_length(sizeof_object() + user_size()); + } + + protected: + + OSMObject(osmium::memory::item_size_type size, osmium::item_type type) : + OSMEntity(size, type), + m_id(0), + m_deleted(false), + m_version(0), + m_timestamp(), + m_uid(0), + m_changeset(0) { + } + + void user_size(string_size_type size) { + *reinterpret_cast(user_position()) = size; + } + + template + T& subitem_of_type() { + for (iterator it = begin(); it != end(); ++it) { + if (it->type() == T::itemtype) { + return reinterpret_cast(*it); + } + } + + static T subitem; + return subitem; + } + + template + const T& subitem_of_type() const { + for (const_iterator it = cbegin(); it != cend(); ++it) { + if (it->type() == T::itemtype) { + return reinterpret_cast(*it); + } + } + + static const T subitem; + return subitem; + } + + public: + + /// Get ID of this object. + object_id_type id() const { + return m_id; + } + + /// Get absolute value of the ID of this object. + unsigned_object_id_type positive_id() const { + return static_cast(std::abs(m_id)); + } + + /** + * Set ID of this object. + * + * @return Reference to object to make calls chainable. + */ + OSMObject& id(object_id_type id) { + m_id = id; + return *this; + } + + /** + * Set ID of this object. + * + * @return Reference to object to make calls chainable. + */ + OSMObject& id(const char* id) { + return this->id(osmium::string_to_object_id(id)); + } + + /// Is this object marked as deleted? + bool deleted() const { + return m_deleted; + } + + /// Is this object marked visible (ie not deleted)? + bool visible() const { + return !deleted(); + } + + /** + * Mark this object as deleted (or not). + * + * @return Reference to object to make calls chainable. + */ + OSMObject& deleted(bool deleted) { + m_deleted = deleted; + return *this; + } + + /** + * Mark this object as visible (ie not deleted) (or not). + * + * @return Reference to object to make calls chainable. + */ + OSMObject& visible(bool visible) { + m_deleted = !visible; + return *this; + } + + /** + * Mark this object as visible (ie not deleted) or deleted. + * + * @param visible Either "true" or "false" + * @return Reference to object to make calls chainable. + */ + OSMObject& visible(const char* visible) { + if (!strcmp("true", visible)) { + this->visible(true); + } else if (!strcmp("false", visible)) { + this->visible(false); + } else { + throw std::invalid_argument("Unknown value for visible attribute (allowed is 'true' or 'false')"); + } + return *this; + } + + /// Get version of this object. + object_version_type version() const { + return m_version; + } + + /** + * Set object version. + * + * @return Reference to object to make calls chainable. + */ + OSMObject& version(object_version_type version) { + m_version = version; + return *this; + } + + /** + * Set object version. + * + * @return Reference to object to make calls chainable. + */ + OSMObject& version(const char* version) { + return this->version(string_to_object_version(version)); + } + + /// Get changeset id of this object. + changeset_id_type changeset() const { + return m_changeset; + } + + /** + * Set changeset id of this object. + * + * @return Reference to object to make calls chainable. + */ + OSMObject& changeset(changeset_id_type changeset) { + m_changeset = changeset; + return *this; + } + + /** + * Set changeset id of this object. + * + * @return Reference to object to make calls chainable. + */ + OSMObject& changeset(const char* changeset) { + return this->changeset(string_to_changeset_id(changeset)); + } + + /// Get user id of this object. + user_id_type uid() const { + return m_uid; + } + + /** + * Set user id of this object. + * + * @return Reference to object to make calls chainable. + */ + OSMObject& uid(user_id_type uid) { + m_uid = uid; + return *this; + } + + /** + * Set user id of this object. + * Sets uid to 0 (anonymous) if the given uid is smaller than 0. + * + * @return Reference to object to make calls chainable. + */ + OSMObject& uid_from_signed(signed_user_id_type uid) { + m_uid = uid < 0 ? 0 : static_cast(uid); + return *this; + } + + /** + * Set user id of this object. + * + * @return Reference to object to make calls chainable. + */ + OSMObject& uid(const char* uid) { + return this->uid_from_signed(string_to_user_id(uid)); + } + + /// Is this user anonymous? + bool user_is_anonymous() const { + return m_uid == 0; + } + + /// Get timestamp when this object last changed. + osmium::Timestamp timestamp() const { + return m_timestamp; + } + + /** + * Set the timestamp when this object last changed. + * + * @param timestamp Timestamp + * @return Reference to object to make calls chainable. + */ + OSMObject& timestamp(const osmium::Timestamp timestamp) { + m_timestamp = timestamp; + return *this; + } + + /// Get user name for this object. + const char* user() const { + return reinterpret_cast(data() + sizeof_object()); + } + + /// Get the list of tags for this object. + TagList& tags() { + return subitem_of_type(); + } + + /// Get the list of tags for this object. + const TagList& tags() const { + return subitem_of_type(); + } + + /** + * Get tag value by key. + * + * Convenience function that will forward to same function on TagList + * object. + */ + const char* get_value_by_key(const char* key, const char* default_value = nullptr) const noexcept { + return tags().get_value_by_key(key, default_value); + } + + /** + * Set named attribute. + * + * @param attr Name of the attribute (must be one of "id", "version", "changeset", "timestamp", "uid", "visible") + * @param value Value of the attribute + */ + void set_attribute(const char* attr, const char* value) { + if (!strcmp(attr, "id")) { + id(value); + } else if (!strcmp(attr, "version")) { + version(value); + } else if (!strcmp(attr, "changeset")) { + changeset(value); + } else if (!strcmp(attr, "timestamp")) { + timestamp(osmium::Timestamp(value)); + } else if (!strcmp(attr, "uid")) { + uid(value); + } else if (!strcmp(attr, "visible")) { + visible(value); + } + } + + typedef osmium::memory::CollectionIterator iterator; + typedef osmium::memory::CollectionIterator const_iterator; + + iterator begin() { + return iterator(subitems_position()); + } + + iterator end() { + return iterator(data() + padded_size()); + } + + const_iterator cbegin() const { + return const_iterator(subitems_position()); + } + + const_iterator cend() const { + return const_iterator(data() + padded_size()); + } + + const_iterator begin() const { + return cbegin(); + } + + const_iterator end() const { + return cend(); + } + + }; // class OSMObject + + static_assert(sizeof(OSMObject) % osmium::memory::align_bytes == 0, "Class osmium::OSMObject has wrong size to be aligned properly!"); + + /** + * OSMObjects are equal if their type, id, and version are equal. + */ + inline bool operator==(const OSMObject& lhs, const OSMObject& rhs) { + return lhs.type() == rhs.type() && + lhs.id() == rhs.id() && + lhs.version() == rhs.version(); + } + + inline bool operator!=(const OSMObject& lhs, const OSMObject& rhs) { + return ! (lhs == rhs); + } + + /** + * OSMObjects can be ordered by type, id and version. + * Note that we use the absolute value of the id for a + * better ordering of objects with negative id. + */ + inline bool operator<(const OSMObject& lhs, const OSMObject& rhs) { + if (lhs.type() != rhs.type()) { + return lhs.type() < rhs.type(); + } + return (lhs.id() == rhs.id() && lhs.version() < rhs.version()) || + lhs.positive_id() < rhs.positive_id(); + } + + inline bool operator>(const OSMObject& lhs, const OSMObject& rhs) { + return rhs < lhs; + } + + inline bool operator<=(const OSMObject& lhs, const OSMObject& rhs) { + return ! (rhs < lhs); + } + + inline bool operator>=(const OSMObject& lhs, const OSMObject& rhs) { + return ! (lhs < rhs); + } + +} // namespace osmium + +#endif // OSMIUM_OSM_OBJECT_HPP diff --git a/ThirdParty/osmium/osm/object_comparisons.hpp b/ThirdParty/osmium/osm/object_comparisons.hpp new file mode 100644 index 000000000..5c2bf6cc6 --- /dev/null +++ b/ThirdParty/osmium/osm/object_comparisons.hpp @@ -0,0 +1,110 @@ +#ifndef OSMIUM_OSM_OBJECT_COMPARISONS_HPP +#define OSMIUM_OSM_OBJECT_COMPARISONS_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 + +namespace osmium { + + /** + * Function object class for comparing OSM objects for equality by type, id, and version. + */ + struct object_equal_type_id_version { + + bool operator()(const osmium::OSMObject& lhs, const osmium::OSMObject& rhs) const { + return lhs == rhs; + } + + bool operator()(const osmium::OSMObject* lhs, const osmium::OSMObject* rhs) const { + return *lhs == *rhs; + } + + }; // struct object_equal_type_id_version + + /** + * Function object class for comparing OSM objects for equality by type and id, + * ignoring the version. + */ + struct object_equal_type_id { + + bool operator()(const osmium::OSMObject& lhs, const osmium::OSMObject& rhs) const { + return lhs.type() == rhs.type() && + lhs.id() == rhs.id(); + } + + bool operator()(const osmium::OSMObject* lhs, const osmium::OSMObject* rhs) const { + return operator()(*lhs, *rhs); + } + + }; // struct object_equal_type_id + + /** + * Function object class for ordering OSM objects by type, id, and version. + */ + struct object_order_type_id_version { + + bool operator()(const osmium::OSMObject& lhs, const osmium::OSMObject& rhs) const { + return lhs < rhs; + } + + bool operator()(const osmium::OSMObject* lhs, const osmium::OSMObject* rhs) const { + return *lhs < *rhs; + } + + }; // struct object_order_type_id_version + + /** + * Function object class for ordering OSM objects by type, id, and reverse version, + * ie objects are ordered by type and id, but later versions of an object are + * ordered before earlier versions of the same object. + */ + struct object_order_type_id_reverse_version { + + bool operator()(const osmium::OSMObject& lhs, const osmium::OSMObject& rhs) const { + if (lhs.type() != rhs.type()) { + return lhs.type() < rhs.type(); + } + return (lhs.id() == rhs.id() && lhs.version() > rhs.version()) || + lhs.positive_id() < rhs.positive_id(); + } + + bool operator()(const osmium::OSMObject* lhs, const osmium::OSMObject* rhs) const { + return operator()(*lhs, *rhs); + } + + }; // struct object_order_type_id_reverse_version + +} // namespace osmium + +#endif // OSMIUM_OSM_OBJECT_COMPARISONS_HPP diff --git a/ThirdParty/osmium/osm/relation.hpp b/ThirdParty/osmium/osm/relation.hpp new file mode 100644 index 000000000..7974e7aad --- /dev/null +++ b/ThirdParty/osmium/osm/relation.hpp @@ -0,0 +1,189 @@ +#ifndef OSMIUM_OSM_RELATION_HPP +#define OSMIUM_OSM_RELATION_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include + +#include // IWYU pragma: keep +#include +#include +#include +#include + +namespace osmium { + + namespace builder { + template class ObjectBuilder; + class RelationMemberListBuilder; + } + + class RelationMember : public osmium::memory::detail::ItemHelper { + + friend class osmium::builder::RelationMemberListBuilder; + + object_id_type m_ref; + item_type m_type; + uint16_t m_flags; + string_size_type m_role_size {0}; + + RelationMember(const RelationMember&) = delete; + RelationMember(RelationMember&&) = delete; + + RelationMember& operator=(const RelationMember&) = delete; + RelationMember& operator=(RelationMember&&) = delete; + + unsigned char* endpos() { + return data() + osmium::memory::padded_length(sizeof(RelationMember) + m_role_size); + } + + const unsigned char* endpos() const { + return data() + osmium::memory::padded_length(sizeof(RelationMember) + m_role_size); + } + + template + friend class osmium::memory::CollectionIterator; + + unsigned char* next() { + if (full_member()) { + return endpos() + reinterpret_cast(endpos())->byte_size(); + } else { + return endpos(); + } + } + + unsigned const char* next() const { + if (full_member()) { + return endpos() + reinterpret_cast(endpos())->byte_size(); + } else { + return endpos(); + } + } + + void set_role_size(string_size_type size) { + m_role_size = size; + } + + public: + + static constexpr item_type collection_type = item_type::relation_member_list; + + RelationMember(const object_id_type ref=0, const item_type type=item_type(), const bool full=false) : + m_ref(ref), + m_type(type), + m_flags(full ? 1 : 0) { + } + + object_id_type ref() const { + return m_ref; + } + + RelationMember& ref(object_id_type ref) { + m_ref = ref; + return *this; + } + + unsigned_object_id_type positive_ref() const { + return static_cast(std::abs(m_ref)); + } + + item_type type() const { + return m_type; + } + + bool full_member() const { + return m_flags == 1; + } + + const char* role() const { + return reinterpret_cast(data() + sizeof(RelationMember)); + } + + OSMObject& get_object() { + return *reinterpret_cast(endpos()); + } + + const OSMObject& get_object() const { + return *reinterpret_cast(endpos()); + } + + }; // class RelationMember + + class RelationMemberList : public osmium::memory::Collection { + + public: + + typedef size_t size_type; + + RelationMemberList() : + osmium::memory::Collection() { + } + + size_type size() const noexcept { + return static_cast(std::distance(begin(), end())); + } + + }; // class RelationMemberList + + static_assert(sizeof(RelationMemberList) % osmium::memory::align_bytes == 0, "Class osmium::RelationMemberList has wrong size to be aligned properly!"); + + class Relation : public OSMObject { + + friend class osmium::builder::ObjectBuilder; + + Relation() : + OSMObject(sizeof(Relation), osmium::item_type::relation) { + } + + public: + + static constexpr osmium::item_type itemtype = osmium::item_type::relation; + + RelationMemberList& members() { + return subitem_of_type(); + } + + const RelationMemberList& members() const { + return subitem_of_type(); + } + + }; // class Relation + + static_assert(sizeof(Relation) % osmium::memory::align_bytes == 0, "Class osmium::Relation has wrong size to be aligned properly!"); + +} // namespace osmium + +#endif // OSMIUM_OSM_RELATION_HPP diff --git a/ThirdParty/osmium/osm/segment.hpp b/ThirdParty/osmium/osm/segment.hpp new file mode 100644 index 000000000..b08679165 --- /dev/null +++ b/ThirdParty/osmium/osm/segment.hpp @@ -0,0 +1,105 @@ +#ifndef OSMIUM_OSM_SEGMENT_HPP +#define OSMIUM_OSM_SEGMENT_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include + +#include +#include + +namespace osmium { + + /** + * A Segment is the directed connection between two Locations. + */ + class Segment { + + osmium::Location m_first; + osmium::Location m_second; + + public: + + explicit constexpr Segment(const osmium::Location& location1, const osmium::Location& location2) : + m_first(location1), + m_second(location2) { + } + + constexpr Segment(const Segment&) = default; + constexpr Segment(Segment&&) = default; + + Segment& operator=(const Segment&) = default; + Segment& operator=(Segment&&) = default; + + ~Segment() = default; + + /// Return first Location of Segment. + OSMIUM_CONSTEXPR osmium::Location first() const { + return m_first; + } + + /// Return second Location of Segment. + OSMIUM_CONSTEXPR osmium::Location second() const { + return m_second; + } + + protected: + + void swap_locations() { + using std::swap; + swap(m_first, m_second); + } + + }; // class Segment + + /// Segments are equal if both their locations are equal + inline OSMIUM_CONSTEXPR bool operator==(const Segment& lhs, const Segment& rhs) { + return lhs.first() == rhs.first() && lhs.second() == rhs.second(); + } + + inline OSMIUM_CONSTEXPR bool operator!=(const Segment& lhs, const Segment& rhs) { + return ! (lhs == rhs); + } + + /** + * Output Segment to a stream. + */ + template + inline std::basic_ostream& operator<<(std::basic_ostream& out, const osmium::Segment& segment) { + return out << segment.first() << "->" << segment.second(); + } + +} // namespace osmium + +#endif // OSMIUM_OSM_SEGMENT_HPP diff --git a/ThirdParty/osmium/osm/tag.hpp b/ThirdParty/osmium/osm/tag.hpp new file mode 100644 index 000000000..df994a134 --- /dev/null +++ b/ThirdParty/osmium/osm/tag.hpp @@ -0,0 +1,140 @@ +#ifndef OSMIUM_OSM_TAG_HPP +#define OSMIUM_OSM_TAG_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include +#include + +#include +#include +#include + +namespace osmium { + + class Tag : public osmium::memory::detail::ItemHelper { + + Tag(const Tag&) = delete; + Tag(Tag&&) = delete; + + Tag& operator=(const Tag&) = delete; + Tag& operator=(Tag&&) = delete; + + template + friend class osmium::memory::CollectionIterator; + + static unsigned char* after_null(unsigned char* ptr) { + return reinterpret_cast(std::strchr(reinterpret_cast(ptr), 0) + 1); + } + + static const unsigned char* after_null(const unsigned char* ptr) { + return reinterpret_cast(std::strchr(reinterpret_cast(ptr), 0) + 1); + } + + unsigned char* next() { + return after_null(after_null(data())); + } + + const unsigned char* next() const { + return after_null(after_null(data())); + } + + public: + + static constexpr item_type collection_type = item_type::tag_list; + + const char* key() const { + return reinterpret_cast(data()); + } + + const char* value() const { + return reinterpret_cast(after_null(data())); + } + + }; // class Tag + + inline bool operator==(const Tag& a, const Tag& b) { + return !std::strcmp(a.key(), b.key()) && !strcmp(a.value(), b.value()); + } + + inline bool operator<(const Tag& a, const Tag& b) { + return (!std::strcmp(a.key(), b.key()) && (std::strcmp(a.value(), b.value()) < 0)) || (std::strcmp(a.key(), b.key()) < 0); + } + + /** + * Output a Tag to a stream. + */ + template + inline std::basic_ostream& operator<<(std::basic_ostream& out, const Tag& tag) { + return out << tag.key() << '=' << tag.value(); + } + + class TagList : public osmium::memory::Collection { + + public: + + typedef size_t size_type; + + TagList() : + osmium::memory::Collection() { + } + + size_type size() const noexcept { + return static_cast(std::distance(begin(), end())); + } + + const char* get_value_by_key(const char* key, const char* default_value = nullptr) const noexcept { + auto result = std::find_if(cbegin(), cend(), [key](const Tag& tag) { + return !strcmp(tag.key(), key); + }); + if (result == cend()) { + return default_value; + } else { + return result->value(); + } + } + + const char* operator[](const char* key) const noexcept { + return get_value_by_key(key); + } + + }; // class TagList + + static_assert(sizeof(TagList) % osmium::memory::align_bytes == 0, "Class osmium::TagList has wrong size to be aligned properly!"); + +} // namespace osmium + +#endif // OSMIUM_OSM_TAG_HPP diff --git a/ThirdParty/osmium/osm/timestamp.hpp b/ThirdParty/osmium/osm/timestamp.hpp new file mode 100644 index 000000000..7e25f83e8 --- /dev/null +++ b/ThirdParty/osmium/osm/timestamp.hpp @@ -0,0 +1,159 @@ +#ifndef OSMIUM_OSM_TIMESTAMP_HPP +#define OSMIUM_OSM_TIMESTAMP_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include +#include +#include +#include + +#include + +namespace osmium { + + /** + * A timestamp. Internal representation is an unsigned 32bit integer + * holding seconds since epoch, so this will overflow in 2038. + */ + class Timestamp { + + // length of ISO timestamp string yyyy-mm-ddThh:mm:ssZ\0 + static constexpr int timestamp_length = 20 + 1; + + /** + * The timestamp format for OSM timestamps in strftime(3) format. + * This is the ISO-Format yyyy-mm-ddThh:mm:ssZ + */ + static const char* timestamp_format() { + static const char f[timestamp_length] = "%Y-%m-%dT%H:%M:%SZ"; + return f; + } + + uint32_t m_timestamp; + + public: + + constexpr Timestamp() : + m_timestamp(0) { + } + + // Not "explicit" so that conversions from time_t work + // like in node.timestamp(123); + constexpr Timestamp(time_t timestamp) : + m_timestamp(static_cast(timestamp)) { + } + + /** + * Construct timestamp from ISO date/time string. + * Throws std::invalid_argument, if the timestamp can not be parsed. + */ + explicit Timestamp(const char* timestamp) { +#ifndef WIN32 + struct tm tm { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + }; + if (strptime(timestamp, timestamp_format(), &tm) == nullptr) { + throw std::invalid_argument("can't parse timestamp"); + } + m_timestamp = static_cast(timegm(&tm)); +#else + struct tm tm; + int n = sscanf(timestamp, "%4d-%2d-%2dT%2d:%2d:%2dZ", &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour, &tm.tm_min, &tm.tm_sec); + if (n != 6) { + throw std::invalid_argument("can't parse timestamp"); + } + tm.tm_year -= 1900; + tm.tm_mon--; + tm.tm_wday = 0; + tm.tm_yday = 0; + tm.tm_isdst = 0; + m_timestamp = _mkgmtime(&tm); +#endif + } + + constexpr time_t seconds_since_epoch() const { + return static_cast(m_timestamp); + } + + constexpr operator time_t() const { + return static_cast(m_timestamp); + } + + /** + * Return UTC Unix time as string in ISO date/time format. + */ + std::string to_iso() const { + if (m_timestamp == 0) { + return std::string(""); + } + struct tm tm; + time_t sse = seconds_since_epoch(); +#ifndef _MSC_VER + gmtime_r(&sse, &tm); +#else + gmtime_s(&tm, &sse); +#endif + + std::string s(timestamp_length, '\0'); + /* This const_cast is ok, because we know we have enough space + in the string for the format we are using (well at least until + the year will have 5 digits). And by setting the size + afterwards from the result of strftime we make sure thats set + right, too. */ + s.resize(strftime(const_cast(s.c_str()), timestamp_length, timestamp_format(), &tm)); + return s; + } + + }; // class Timestamp + + inline OSMIUM_CONSTEXPR Timestamp start_of_time() { + return Timestamp(1); + } + + inline OSMIUM_CONSTEXPR Timestamp end_of_time() { + return Timestamp(std::numeric_limits::max()); + } + + template + inline std::basic_ostream& operator<<(std::basic_ostream& out, Timestamp timestamp) { + out << timestamp.to_iso(); + return out; + } + +} // namespace osmium + +#endif // OSMIUM_OSM_TIMESTAMP_HPP diff --git a/ThirdParty/osmium/osm/types.hpp b/ThirdParty/osmium/osm/types.hpp new file mode 100644 index 000000000..532b5497c --- /dev/null +++ b/ThirdParty/osmium/osm/types.hpp @@ -0,0 +1,83 @@ +#ifndef OSMIUM_OSM_TYPES_HPP +#define OSMIUM_OSM_TYPES_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include + +namespace osmium { + + /* + * The following typedefs are chosen so that they can represent all needed + * numbers and still be reasonably space efficient. As the OSM database + * needs 64 bit IDs for nodes, this size is used for all object IDs. + */ + typedef int64_t object_id_type; ///< Type for OSM object (node, way, or relation) IDs. + typedef uint64_t unsigned_object_id_type; ///< Type for OSM object (node, way, or relation) IDs where we only allow positive IDs. + typedef uint32_t object_version_type; ///< Type for OSM object version number. + typedef uint32_t changeset_id_type; ///< Type for OSM changeset IDs. + typedef uint32_t user_id_type; ///< Type for OSM user IDs. + typedef int32_t signed_user_id_type; ///< Type for signed OSM user IDs. + typedef uint32_t num_changes_type; ///< Type for changeset num_changes. + + /** + * Size for strings in OSM data such as user names, tag keys, roles, etc. + * In Osmium they can be up to 2^16 bytes long, but OSM usually has lower + * defined limits. + */ + typedef uint16_t string_size_type; + + inline object_id_type string_to_object_id(const char* string) { + return std::atoll(string); + } + + inline object_version_type string_to_object_version(const char* string) { + return static_cast(std::atol(string)); + } + + inline changeset_id_type string_to_changeset_id(const char* string) { + return static_cast(std::atol(string)); + } + + inline signed_user_id_type string_to_user_id(const char* string) { + return static_cast(std::atol(string)); + } + + inline num_changes_type string_to_num_changes(const char* string) { + return static_cast(std::atol(string)); + } + +} // namespace osmium + +#endif // OSMIUM_OSM_TYPES_HPP diff --git a/ThirdParty/osmium/osm/undirected_segment.hpp b/ThirdParty/osmium/osm/undirected_segment.hpp new file mode 100644 index 000000000..8805162ec --- /dev/null +++ b/ThirdParty/osmium/osm/undirected_segment.hpp @@ -0,0 +1,100 @@ +#ifndef OSMIUM_OSM_UNDIRECTED_SEGMENT_HPP +#define OSMIUM_OSM_UNDIRECTED_SEGMENT_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 + +#include +#include + +namespace osmium { + + /** + * Undirected connection between two Locations. The first Location is + * always equal or "smaller" than the second Location, ie to the left + * and down. + */ + class UndirectedSegment : public Segment { + + public: + + explicit UndirectedSegment(const osmium::Location& location1, const osmium::Location& location2) : + Segment(location1, location2) { + if (location2 < location1) { + swap_locations(); + } + } + + UndirectedSegment(const UndirectedSegment&) = default; + UndirectedSegment(UndirectedSegment&&) = default; + + UndirectedSegment& operator=(const UndirectedSegment&) = default; + UndirectedSegment& operator=(UndirectedSegment&&) = default; + + ~UndirectedSegment() = default; + + }; // class UndirectedSegment + + /** + * UndirectedSegments 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 UndirectedSegment& lhs, const UndirectedSegment& rhs) { + return (lhs.first() == rhs.first() && lhs.second() < rhs.second()) || lhs.first() < rhs.first(); + } + + inline bool operator>(const UndirectedSegment& lhs, const UndirectedSegment& rhs) { + return rhs < lhs; + } + + inline bool operator<=(const UndirectedSegment& lhs, const UndirectedSegment& rhs) { + return ! (rhs < lhs); + } + + inline bool operator>=(const UndirectedSegment& lhs, const UndirectedSegment& rhs) { + return ! (lhs < rhs); + } + + /** + * Output UndirectedSegment to a stream. + */ + template + inline std::basic_ostream& operator<<(std::basic_ostream& out, const osmium::UndirectedSegment& segment) { + return out << segment.first() << "--" << segment.second(); + } + +} // namespace osmium + +#endif // OSMIUM_OSM_UNDIRECTED_SEGMENT_HPP diff --git a/ThirdParty/osmium/osm/way.hpp b/ThirdParty/osmium/osm/way.hpp new file mode 100644 index 000000000..c55698c21 --- /dev/null +++ b/ThirdParty/osmium/osm/way.hpp @@ -0,0 +1,115 @@ +#ifndef OSMIUM_OSM_WAY_HPP +#define OSMIUM_OSM_WAY_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include +#include +#include + +namespace osmium { + + namespace builder { + template class ObjectBuilder; + } + + /** + * List of node references (id and location) in a way. + */ + class WayNodeList : public NodeRefList { + + public: + + WayNodeList(): + NodeRefList() { + } + + }; // class WayNodeList + + static_assert(sizeof(WayNodeList) % osmium::memory::align_bytes == 0, "Class osmium::WayNodeList has wrong size to be aligned properly!"); + + class Way : public OSMObject { + + friend class osmium::builder::ObjectBuilder; + + Way() : + OSMObject(sizeof(Way), osmium::item_type::way) { + } + + public: + + WayNodeList& nodes() { + return subitem_of_type(); + } + + const WayNodeList& nodes() const { + return subitem_of_type(); + } + + /** + * Update all nodes in a way with the ID of the given NodeRef with the + * location of the given NodeRef. + */ + void update_node_location(const NodeRef& new_node_ref) { + for (auto& node_ref : nodes()) { + if (node_ref.ref() == new_node_ref.ref()) { + node_ref.location(new_node_ref.location()); + } + } + } + + /** + * Do the nodes in this way form a closed ring? + */ + bool is_closed() const { + return nodes().is_closed(); + } + + bool ends_have_same_id() const { + return nodes().ends_have_same_id(); + } + + bool ends_have_same_location() const { + return nodes().ends_have_same_location(); + } + + }; // class Way + + static_assert(sizeof(Way) % osmium::memory::align_bytes == 0, "Class osmium::Way has wrong size to be aligned properly!"); + +} // namespace osmium + +#endif // OSMIUM_OSM_WAY_HPP diff --git a/ThirdParty/osmium/relations/collector.hpp b/ThirdParty/osmium/relations/collector.hpp new file mode 100644 index 000000000..cc7a5964e --- /dev/null +++ b/ThirdParty/osmium/relations/collector.hpp @@ -0,0 +1,535 @@ +#ifndef OSMIUM_RELATIONS_COLLECTOR_HPP +#define OSMIUM_RELATIONS_COLLECTOR_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include // IWYU pragma: keep +#include +#include +#include +#include + +#include +#include + +namespace osmium { + + class Node; + class Way; + + /** + * @brief Code related to the assembly of OSM relations + */ + namespace relations { + + /** + * The Collector class collects members of a relation. This is a generic + * base class that can be used to assemble all kinds of relations. It has numerous + * hooks you can implement in derived classes to customize its behaviour. + * + * The collector provides two handlers (HandlerPass1 and HandlerPass2) for a first + * and second pass through an input file, respectively. In the first pass all + * relations we are interested in are stored in RelationMeta objects in the + * m_relations vector. All members we are interested in are stored in MemberMeta + * objects in the m_member_meta vectors. + * The MemberMeta objects also store the information where the relations containing + * those members are to be found. + * + * Later the m_member_meta vectors are sorted according to the + * member ids so that a binary search (with std::equal_range) can be used in the second + * pass to find the parent relations for each node, way, or relation coming along. + * The member objects are stored together with their relation and once a relation + * is complete the complete_relation() method is called which you must overwrite in + * a derived class of Collector. + * + * @tparam TCollector Derived class of this class. + * + * @tparam TNodes Are we interested in member nodes? + * + * @tparam TWays Are we interested in member ways? + * + * @tparam TRelations Are we interested in member relations? + */ + template + class Collector { + + /** + * This is the handler class for the first pass of the Collector. + */ + class HandlerPass1 : public osmium::handler::Handler { + + TCollector& m_collector; + + public: + + HandlerPass1(TCollector& collector) : + m_collector(collector) { + } + + void relation(const osmium::Relation& relation) { + if (m_collector.keep_relation(relation)) { + m_collector.add_relation(relation); + } + } + + }; // class HandlerPass1 + + /** + * This is the handler class for the second pass of the Collector. + */ + class HandlerPass2 : public osmium::handler::Handler { + + TCollector& m_collector; + + /** + * This variable is initialized with the number of different + * kinds of OSM objects we are interested in. If we only need + * way members (for instance for the multipolygon collector) + * it is intialized with 1 for instance. If node and way + * members are needed, it is initialized with 2. + * + * In the after_* methods of this handler, it is decremented + * and once it reaches 0, we know we have all members available + * that we are ever going to get. + */ + int m_want_types; + + /** + * Find this object in the member vectors and add it to all + * relations that need it. + * + * @returns true if the member was added to at least one + * relation and false otherwise + */ + bool find_and_add_object(const osmium::OSMObject& object) { + auto& mmv = m_collector.member_meta(object.type()); + auto range = std::equal_range(mmv.begin(), mmv.end(), MemberMeta(object.id())); + + if (range.first == range.second) { + // nothing found + return false; + } + + { + const size_t member_offset = m_collector.members_buffer().committed(); + m_collector.members_buffer().add_item(object); + m_collector.members_buffer().commit(); + + for (auto it = range.first; it != range.second; ++it) { + it->buffer_offset(member_offset); + } + } + + for (auto it = range.first; it != range.second; ++it) { + MemberMeta& member_meta = *it; + assert(member_meta.member_id() == object.id()); + assert(member_meta.relation_pos() < m_collector.m_relations.size()); + RelationMeta& relation_meta = m_collector.m_relations[member_meta.relation_pos()]; +// std::cerr << " => " << member_meta.member_pos() << " < " << m_collector.get_relation(relation_meta).members().size() << " (id=" << m_collector.get_relation(relation_meta).id() << ")\n"; + assert(member_meta.member_pos() < m_collector.get_relation(relation_meta).members().size()); +// std::cerr << " add way " << member_meta.member_id() << " to rel " << m_collector.get_relation(relation_meta).id() << " at pos " << member_meta.member_pos() << "\n"; + relation_meta.got_one_member(); + if (relation_meta.has_all_members()) { + const size_t relation_offset = member_meta.relation_pos(); + m_collector.complete_relation(relation_meta); + m_collector.m_relations[relation_offset] = RelationMeta(); + m_collector.possibly_purge_removed_members(); + } + } + + return true; + } + + public: + + HandlerPass2(TCollector& collector) : + m_collector(collector), + m_want_types((TNodes?1:0) + (TWays?1:0) + (TRelations?1:0)) { + } + + void node(const osmium::Node& node) { + if (TNodes) { + if (! find_and_add_object(node)) { + m_collector.node_not_in_any_relation(node); + } + } + } + + void way(const osmium::Way& way) { + if (TWays) { + if (! find_and_add_object(way)) { + m_collector.way_not_in_any_relation(way); + } + } + } + + void relation(const osmium::Relation& relation) { + if (TRelations) { + if (! find_and_add_object(relation)) { + m_collector.relation_not_in_any_relation(relation); + } + } + } + + void flush() { + m_collector.flush(); + } + + }; // class HandlerPass2 + + HandlerPass2 m_handler_pass2; + + // All relations we are interested in will be kept in this buffer + osmium::memory::Buffer m_relations_buffer; + + // All members we are interested in will be kept in this buffer + osmium::memory::Buffer m_members_buffer; + + /// Vector with all relations we are interested in + std::vector m_relations; + + /** + * One vector each for nodes, ways, and relations containing all + * mappings from member ids to their relations. + */ + std::vector m_member_meta[3]; + + int m_count_complete = 0; + + typedef std::function callback_func_type; + callback_func_type m_callback; + + static constexpr size_t initial_buffer_size = 1024 * 1024; + + public: + + /** + * Create an Collector. + */ + Collector() : + m_handler_pass2(*static_cast(this)), + m_relations_buffer(initial_buffer_size, osmium::memory::Buffer::auto_grow::yes), + m_members_buffer(initial_buffer_size, osmium::memory::Buffer::auto_grow::yes), + m_relations(), + m_member_meta() { + } + + protected: + + std::vector& member_meta(const item_type type) { + return m_member_meta[static_cast(type) - 1]; + } + + callback_func_type callback() { + return m_callback; + } + + const std::vector& relations() const { + return m_relations; + } + + /** + * This method is called from the first pass handler for every + * relation in the input, to check whether it should be kept. + * + * Overwrite this method in a child class to only add relations + * you are interested in, for instance depending on the type tag. + * Storing relations takes a lot of memory, so it makes sense to + * filter this as much as possible. + */ + bool keep_relation(const osmium::Relation& /*relation*/) const { + return true; + } + + /** + * This method is called for every member of every relation that + * should be kept. It should decide if the member is interesting or + * not and return true or false to signal that. Only interesting + * members are later added to the relation. + * + * Overwrite this method in a child class. In the MultiPolygonCollector + * this is for instance used to only keep members of type way and + * ignore all others. + */ + bool keep_member(const osmium::relations::RelationMeta& /*relation_meta*/, const osmium::RelationMember& /*member*/) const { + return true; + } + + /** + * This method is called for all nodes that are not a member of + * any relation. + * + * Overwrite this method in a child class if you are interested + * in this. + */ + void node_not_in_any_relation(const osmium::Node& /*node*/) { + } + + /** + * This method is called for all ways that are not a member of + * any relation. + * + * Overwrite this method in a child class if you are interested + * in this. + */ + void way_not_in_any_relation(const osmium::Way& /*way*/) { + } + + /** + * This method is called for all relations that are not a member of + * any relation. + * + * Overwrite this method in a child class if you are interested + * in this. + */ + void relation_not_in_any_relation(const osmium::Relation& /*relation*/) { + } + + /** + * This method is called from the 2nd pass handler when all objects + * of types we are interested in have been seen. + * + * Overwrite this method in a child class if you are interested + * in this. + * + * Note that even after this call members might be missing if they + * were not in the input file! The derived class has to handle this + * case. + */ + void flush() { + } + + /** + * This removes all relations that have already been assembled + * from the m_relations vector. + */ + void clean_assembled_relations() { + m_relations.erase( + std::remove_if(m_relations.begin(), m_relations.end(), has_all_members()), + m_relations.end() + ); + } + + const osmium::Relation& get_relation(size_t offset) const { + return m_relations_buffer.get(offset); + } + + /** + * Get the relation from a relation_meta. + */ + const osmium::Relation& get_relation(const RelationMeta& relation_meta) const { + return get_relation(relation_meta.relation_offset()); + } + + osmium::OSMObject& get_member(size_t offset) const { + return m_members_buffer.get(offset); + } + + /** + * Tell the Collector that you are interested in this relation + * and want it kept until all members have been assembled and + * it is handed back to you. + * + * The relation is copied and stored in a buffer inside the + * collector. + */ + void add_relation(const osmium::Relation& relation) { + const size_t offset = m_relations_buffer.committed(); + m_relations_buffer.add_item(relation); + + RelationMeta relation_meta(offset); + + int n=0; + for (auto& member : m_relations_buffer.get(offset).members()) { + if (static_cast(this)->keep_member(relation_meta, member)) { + member_meta(member.type()).emplace_back(member.ref(), m_relations.size(), n); + relation_meta.increment_need_members(); + } else { + member.ref(0); // set member id to zero to indicate we are not interested + } + ++n; + } + + assert(offset == m_relations_buffer.committed()); + if (relation_meta.has_all_members()) { + m_relations_buffer.rollback(); + } else { + m_relations_buffer.commit(); + m_relations.push_back(std::move(relation_meta)); +// std::cerr << "added relation id=" << relation.id() << "\n"; + } + } + + /** + * Sort the vectors with the member infos so that we can do binary + * search on them. + */ + void sort_member_meta() { +/* std::cerr << "relations: " << m_relations.size() << "\n"; + std::cerr << "node members: " << m_member_meta[0].size() << "\n"; + std::cerr << "way members: " << m_member_meta[1].size() << "\n"; + std::cerr << "relation members: " << m_member_meta[2].size() << "\n";*/ + std::sort(m_member_meta[0].begin(), m_member_meta[0].end()); + std::sort(m_member_meta[1].begin(), m_member_meta[1].end()); + std::sort(m_member_meta[2].begin(), m_member_meta[2].end()); + } + + public: + + uint64_t used_memory() const { + const uint64_t nmembers = m_member_meta[0].capacity() + m_member_meta[1].capacity() + m_member_meta[2].capacity(); + const uint64_t members = nmembers * sizeof(MemberMeta); + const uint64_t relations = m_relations.capacity() * sizeof(RelationMeta); + const uint64_t relations_buffer_capacity = m_relations_buffer.capacity(); + const uint64_t members_buffer_capacity = m_members_buffer.capacity(); + + std::cout << " nR = m_relations.capacity() ........... = " << std::setw(12) << m_relations.capacity() << "\n"; + std::cout << " nMN = m_member_meta[NODE].capacity() ... = " << std::setw(12) << m_member_meta[0].capacity() << "\n"; + std::cout << " nMW = m_member_meta[WAY].capacity() .... = " << std::setw(12) << m_member_meta[1].capacity() << "\n"; + std::cout << " nMR = m_member_meta[RELATION].capacity() = " << std::setw(12) << m_member_meta[2].capacity() << "\n"; + std::cout << " nM = m_member_meta[*].capacity() ...... = " << std::setw(12) << nmembers << "\n"; + + std::cout << " sRM = sizeof(RelationMeta) ............. = " << std::setw(12) << sizeof(RelationMeta) << "\n"; + std::cout << " sMM = sizeof(MemberMeta) ............... = " << std::setw(12) << sizeof(MemberMeta) << "\n\n"; + + std::cout << " nR * sRM ............................... = " << std::setw(12) << relations << "\n"; + std::cout << " nM * sMM ............................... = " << std::setw(12) << members << "\n"; + std::cout << " relations_buffer_capacity .............. = " << std::setw(12) << relations_buffer_capacity << "\n"; + std::cout << " members_buffer_capacity ................ = " << std::setw(12) << members_buffer_capacity << "\n"; + + const uint64_t total = relations + members + relations_buffer_capacity + members_buffer_capacity; + + std::cout << " total .................................. = " << std::setw(12) << total << "\n"; + std::cout << " =======================================================\n"; + + return relations_buffer_capacity + members_buffer_capacity + relations + members; + } + + /** + * Return reference to second pass handler. + */ + HandlerPass2& handler(const callback_func_type& callback = nullptr) { + m_callback = callback; + return m_handler_pass2; + } + + osmium::memory::Buffer& members_buffer() { + return m_members_buffer; + } + + size_t get_offset(osmium::item_type type, osmium::object_id_type id) { + const auto& mmv = member_meta(type); + const auto range = std::equal_range(mmv.cbegin(), mmv.cend(), MemberMeta(id)); + assert(range.first != range.second); + return range.first->buffer_offset(); + } + + template + void read_relations(TIter begin, TIter end) { + HandlerPass1 handler(*static_cast(this)); + osmium::apply(begin, end, handler); + sort_member_meta(); + } + + template + void read_relations(TSource& source) { + read_relations(std::begin(source), std::end(source)); + source.close(); + } + + void moving_in_buffer(size_t old_offset, size_t new_offset) { + const osmium::OSMObject& object = m_members_buffer.get(old_offset); + auto& mmv = member_meta(object.type()); + auto range = std::equal_range(mmv.begin(), mmv.end(), osmium::relations::MemberMeta(object.id())); + for (auto it = range.first; it != range.second; ++it) { + assert(it->buffer_offset() == old_offset); + it->buffer_offset(new_offset); + } + } + + /** + * Decide whether to purge removed members and then do it. + * + * Currently the purging is done every thousand calls. + * This could probably be improved upon. + */ + void possibly_purge_removed_members() { + ++m_count_complete; + if (m_count_complete > 10000) { // XXX + const size_t size_before = m_members_buffer.committed(); + m_members_buffer.purge_removed(this); + const size_t size_after = m_members_buffer.committed(); + double percent = size_before - size_after; + percent /= size_before; + percent *= 100; + std::cerr << "PURGE (size before=" << size_before << " after=" << size_after << " purged=" << (size_before - size_after) << " / " << static_cast(percent) << "%)\n"; + m_count_complete = 0; + } + } + + /** + * Get a vector with pointers to all Relations that could not + * be completed, because members were missing in the input + * data. + * + * Note that these pointers point into memory allocated and + * owned by the Collector object. + */ + std::vector get_incomplete_relations() const { + std::vector relations; + for (const auto& relation_meta : m_relations) { + if (!relation_meta.has_all_members()) { + relations.push_back(&get_relation(relation_meta)); + } + } + return relations; + } + + }; // class Collector + + } // namespace relations + +} // namespace osmium + +#endif // OSMIUM_RELATIONS_COLLECTOR_HPP diff --git a/ThirdParty/osmium/relations/detail/member_meta.hpp b/ThirdParty/osmium/relations/detail/member_meta.hpp new file mode 100644 index 000000000..f6105e559 --- /dev/null +++ b/ThirdParty/osmium/relations/detail/member_meta.hpp @@ -0,0 +1,131 @@ +#ifndef OSMIUM_RELATIONS_DETAIL_MEMBER_META_HPP +#define OSMIUM_RELATIONS_DETAIL_MEMBER_META_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include + +#include + +namespace osmium { + + namespace relations { + + /** + * Helper class for the Collector class. + * + * Stores an object ID and information where the object should be + * stored. + */ + class MemberMeta { + + /** + * Object ID of this relation member. Can be a node, way, or relation ID. + * It depends on the vector in which this object is stored which kind of + * object is referenced here. + */ + osmium::object_id_type m_member_id; + + /** + * Position of the relation this member is a part of in the + * m_relations vector. + */ + size_t m_relation_pos; + + /** + * Position of this member in the list of members of the + * relation this member is a part of. + */ + size_t m_member_pos; + + /** + * Offset in the buffer where the object is stored. + */ + size_t m_buffer_offset { 0 }; + + public: + + /** + * Create new MemberMeta. The variant with zeros for relation_pos and + * member_pos is used to create dummy MemberMeta that can be compared + * to the MemberMeta in the vectors using the equal_range algorithm. + */ + explicit MemberMeta(osmium::object_id_type member_id, size_t relation_pos=0, size_t member_pos=0) : + m_member_id(member_id), + m_relation_pos(relation_pos), + m_member_pos(member_pos) { + } + + osmium::object_id_type member_id() const { + return m_member_id; + } + + size_t relation_pos() const { + return m_relation_pos; + } + + size_t member_pos() const { + return m_member_pos; + } + + size_t buffer_offset() const { + return m_buffer_offset; + } + + void buffer_offset(size_t offset) { + m_buffer_offset = offset; + } + + }; // class MemberMeta + + /** + * Compares two MemberMeta objects by only looking at the member id. + * Used to sort a vector of MemberMeta objects and to later find + * them using binary search. + */ + inline bool operator<(const MemberMeta& a, const MemberMeta& b) { + return a.member_id() < b.member_id(); + } + + template + inline std::basic_ostream& operator<<(std::basic_ostream& out, const MemberMeta& mm) { + out << "MemberMeta(member_id=" << mm.member_id() << " relation_pos=" << mm.relation_pos() << " member_pos=" << mm.member_pos() << " buffer_offset=" << mm.buffer_offset() << ")"; + return out; + } + + } // namespace relations + +} // namespace osmium + +#endif // OSMIUM_RELATIONS_DETAIL_MEMBER_META_HPP diff --git a/ThirdParty/osmium/relations/detail/relation_meta.hpp b/ThirdParty/osmium/relations/detail/relation_meta.hpp new file mode 100644 index 000000000..a9b184ea6 --- /dev/null +++ b/ThirdParty/osmium/relations/detail/relation_meta.hpp @@ -0,0 +1,136 @@ +#ifndef OSMIUM_RELATIONS_DETAIL_RELATION_META_HPP +#define OSMIUM_RELATIONS_DETAIL_RELATION_META_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include + +namespace osmium { + + namespace relations { + + /** + * Helper class for the Collector class. + * + * Stores information needed to collect all members of a relation. This + * includes the offset of the relation in a buffer plus the information + * needed to add members to this relation. + */ + class RelationMeta { + + /// The relation we are assembling. + size_t m_relation_offset; + + /** + * The number of members still needed before the relation is complete. + * This will be set to the number of members we are interested in and + * then count down for every member we find. When it is 0, the relation + * is complete. + */ + int m_need_members = 0; + + public: + + /** + * Initialize an empty RelationMeta. This is needed to zero out relations + * that have been completed. + */ + RelationMeta() : + m_relation_offset(0) { + } + + explicit RelationMeta(size_t relation_offset) : + m_relation_offset(relation_offset) { + } + + /** + * Get offset of relation in buffer. + */ + size_t relation_offset() const { + return m_relation_offset; + } + + /** + * Increment the m_need_members counter. + */ + void increment_need_members() { + ++m_need_members; + } + + /** + * This decrements the "members needed" counter. + */ + void got_one_member() { + assert(m_need_members > 0); + --m_need_members; + } + + /** + * Returns true if all members for this relation are available. + */ + bool has_all_members() const { + return m_need_members == 0; + } + + }; // class RelationMeta + + template + inline std::basic_ostream& operator<<(std::basic_ostream& out, const RelationMeta& rm) { + out << "RelationMeta(relation_offset=" << rm.relation_offset() << " has_all_members=" << rm.has_all_members() << ")"; + return out; + } + + /** + * Function object to check if a relation is complete. + */ + struct has_all_members { + + typedef RelationMeta& argument_type; + typedef bool result_type; + + /** + * @return true if this relation is complete, false otherwise. + */ + bool operator()(RelationMeta& relation_info) const { + return relation_info.has_all_members(); + } + + }; // struct has_all_members + + } // namespace relations + +} // namespace osmium + +#endif // OSMIUM_RELATIONS_DETAIL_RELATION_META_HPP diff --git a/ThirdParty/osmium/tags/filter.hpp b/ThirdParty/osmium/tags/filter.hpp new file mode 100644 index 000000000..a55dcf718 --- /dev/null +++ b/ThirdParty/osmium/tags/filter.hpp @@ -0,0 +1,148 @@ +#ifndef OSMIUM_TAGS_FILTER_HPP +#define OSMIUM_TAGS_FILTER_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include + +#include + +#include +#include + +namespace osmium { + + namespace tags { + + template + struct match_key { + bool operator()(const TKey& rule_key, const char* tag_key) { + return rule_key == tag_key; + } + }; + + struct match_key_prefix { + bool operator()(const std::string& rule_key, const char* tag_key) { + return rule_key.compare(0, std::string::npos, tag_key, 0, rule_key.size()) == 0; + } + }; + + template + struct match_value { + bool operator()(const TValue& rule_value, const char* tag_value) { + return rule_value == tag_value; + } + }; + + template <> + struct match_value { + bool operator()(const bool, const char*) { + return true; + } + }; + + template , class TValueComp=match_value> + class Filter { + + typedef TKey key_type; + typedef typename std::conditional::value, bool, TValue>::type value_type; + + struct Rule { + key_type key; + value_type value; + bool ignore_value; + bool result; + + explicit Rule(bool r, bool ignore, const key_type& k, const value_type& v) : + key(k), + value(v), + ignore_value(ignore), + result(r) { + } + + explicit Rule(bool r, bool ignore, const key_type& k) : + key(k), + value(), + ignore_value(ignore), + result(r) { + } + + }; + + std::vector m_rules; + bool m_default_result; + + public: + + typedef Filter filter_type; + typedef const osmium::Tag& argument_type; + typedef bool result_type; + typedef boost::filter_iterator iterator; + + explicit Filter(bool default_result = false) : + m_default_result(default_result) { + } + + template ::value, int>::type = 0> + Filter& add(bool result, const key_type& key, const value_type& value) { + m_rules.emplace_back(result, false, key, value); + return *this; + } + + Filter& add(bool result, const key_type& key) { + m_rules.emplace_back(result, true, key); + return *this; + } + + bool operator()(const osmium::Tag& tag) const { + for (const Rule& rule : m_rules) { + if (TKeyComp()(rule.key, tag.key()) && (rule.ignore_value || TValueComp()(rule.value, tag.value()))) { + return rule.result; + } + } + return m_default_result; + } + + }; // Filter + + typedef Filter KeyValueFilter; + typedef Filter KeyFilter; + typedef Filter KeyPrefixFilter; + + } // namespace tags + +} // namespace osmium + +#endif // OSMIUM_TAGS_FILTER_HPP diff --git a/ThirdParty/osmium/tags/regex_filter.hpp b/ThirdParty/osmium/tags/regex_filter.hpp new file mode 100644 index 000000000..1f30cba7a --- /dev/null +++ b/ThirdParty/osmium/tags/regex_filter.hpp @@ -0,0 +1,58 @@ +#ifndef OSMIUM_TAGS_REGEX_FILTER_HPP +#define OSMIUM_TAGS_REGEX_FILTER_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2014 Jochen Topf 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 +#include + +#include + +namespace osmium { + + namespace tags { + + template <> + struct match_value { + bool operator()(const std::regex& rule_value, const char* tag_value) { + return std::regex_match(tag_value, rule_value); + } + }; + + typedef Filter RegexFilter; + + } // namespace tags + +} // namespace osmium + +#endif // OSMIUM_TAGS_REGEX_FILTER_HPP diff --git a/ThirdParty/osmium/tags/taglist.hpp b/ThirdParty/osmium/tags/taglist.hpp new file mode 100644 index 000000000..c8c0865d1 --- /dev/null +++ b/ThirdParty/osmium/tags/taglist.hpp @@ -0,0 +1,67 @@ +#ifndef OSMIUM_TAGS_TAGLIST_HPP +#define OSMIUM_TAGS_TAGLIST_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2014 Jochen Topf 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 +#include + +#include + +namespace osmium { + + /** + * @brief Code related to working with OSM tags + */ + namespace tags { + + template + inline bool match_any_of(const osmium::TagList& tag_list, TFilter&& filter) { + return std::any_of(tag_list.begin(), tag_list.end(), std::forward(filter)); + } + + template + inline bool match_all_of(const osmium::TagList& tag_list, TFilter&& filter) { + return std::all_of(tag_list.begin(), tag_list.end(), std::forward(filter)); + } + + template + inline bool match_none_of(const osmium::TagList& tag_list, TFilter&& filter) { + return std::none_of(tag_list.begin(), tag_list.end(), std::forward(filter)); + } + + } // namespace tags + +} // namespace osmium + +#endif // OSMIUM_TAGS_TAGLIST_HPP diff --git a/ThirdParty/osmium/thread/checked_task.hpp b/ThirdParty/osmium/thread/checked_task.hpp new file mode 100644 index 000000000..75c664c99 --- /dev/null +++ b/ThirdParty/osmium/thread/checked_task.hpp @@ -0,0 +1,106 @@ +#ifndef OSMIUM_THREAD_CHECKED_TASK_HPP +#define OSMIUM_THREAD_CHECKED_TASK_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include + +namespace osmium { + + namespace thread { + + template + class CheckedTask { + + std::thread m_thread; + std::future m_future; + + public: + + template + explicit CheckedTask(TArgs&&... args) { + std::packaged_task pack_task(T(std::forward(args)...)); + m_future = pack_task.get_future(); + m_thread = std::thread(std::move(pack_task)); + } + + ~CheckedTask() { + // Make sure task is done. + if (m_thread.joinable()) { + m_thread.join(); + } + } + + CheckedTask(const CheckedTask&) = delete; + CheckedTask& operator=(const CheckedTask&) = delete; + + /** + * Check task for exceptions. + * + * If an exception happened in the task, re-throw it in this + * thread. This will not do anything if there was no exception. + */ + void check_for_exception() { + if (m_future.valid() && m_future.wait_for(std::chrono::seconds(0)) == std::future_status::ready) { + m_future.get(); + } + } + + /** + * Close the task. This will raise in this thread any exception the + * task generated in the other thread. + */ + void close() { + // If an exception happened in the task, re-throw + // it in this thread. This will block if the task + // isn't finished. + if (m_future.valid()) { + m_future.get(); + } + + // Make sure task is done. + if (m_thread.joinable()) { + m_thread.join(); + } + } + + }; // class CheckedTask + + } // namespace thread + +} // namespace osmium + +#endif // OSMIUM_THREAD_CHECKED_TASK_HPP diff --git a/ThirdParty/osmium/thread/function_wrapper.hpp b/ThirdParty/osmium/thread/function_wrapper.hpp new file mode 100644 index 000000000..ad0d14d49 --- /dev/null +++ b/ThirdParty/osmium/thread/function_wrapper.hpp @@ -0,0 +1,104 @@ +#ifndef OSMIUM_THREAD_FUNCTION_WRAPPER_HPP +#define OSMIUM_THREAD_FUNCTION_WRAPPER_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include + +namespace osmium { + + namespace thread { + + class function_wrapper { + + struct impl_base { + virtual void call() = 0; + virtual ~impl_base() { + } + }; + + std::unique_ptr impl; + + template + struct impl_type : impl_base { + F m_functor; + + impl_type(F&& functor) : + m_functor(std::move(functor)) { + } + + void call() { + m_functor(); + } + }; + + public: + + // Constructor must not be "explicit" for wrapper + // to work seemlessly. + template + function_wrapper(F&& f) : + impl(new impl_type(std::move(f))) { + } + + void operator()() { + impl->call(); + } + + function_wrapper() = default; + + function_wrapper(function_wrapper&& other) : + impl(std::move(other.impl)) { + } + + function_wrapper& operator=(function_wrapper&& other) { + impl = std::move(other.impl); + return *this; + } + + function_wrapper(const function_wrapper&) = delete; + function_wrapper(function_wrapper&) = delete; + function_wrapper& operator=(const function_wrapper&) = delete; + + explicit operator bool() const { + return static_cast(impl); + } + + }; // class function_wrapper + + } // namespace thread + +} // namespace osmium + +#endif // OSMIUM_THREAD_FUNCTION_WRAPPER_HPP diff --git a/ThirdParty/osmium/thread/name.hpp b/ThirdParty/osmium/thread/name.hpp new file mode 100644 index 000000000..20ec5c4b9 --- /dev/null +++ b/ThirdParty/osmium/thread/name.hpp @@ -0,0 +1,61 @@ +#ifndef OSMIUM_THREAD_NAME_HPP +#define OSMIUM_THREAD_NAME_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#endif + +namespace osmium { + + namespace thread { + + /** + * Set name of current thread for debugging. This only works on Linux. + */ +#ifdef __linux__ + inline void set_thread_name(const char* name) { + prctl(PR_SET_NAME, name, 0, 0, 0); + } +#else + inline void set_thread_name(const char*) { + // intentionally left blank + } +#endif + + } // namespace thread + +} // namespace osmium + +#endif // OSMIUM_THREAD_NAME_HPP diff --git a/ThirdParty/osmium/thread/pool.hpp b/ThirdParty/osmium/thread/pool.hpp new file mode 100644 index 000000000..2e6d6356f --- /dev/null +++ b/ThirdParty/osmium/thread/pool.hpp @@ -0,0 +1,180 @@ +#ifndef OSMIUM_THREAD_POOL_HPP +#define OSMIUM_THREAD_POOL_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +namespace osmium { + + /** + * @brief Threading-related low-level code + */ + namespace thread { + + /** + * Thread pool. + */ + class Pool { + + // This class makes sure pool threads are joined when the pool is destructed + class thread_joiner { + + std::vector& m_threads; + + public: + + explicit thread_joiner(std::vector& threads) : + m_threads(threads) { + } + + ~thread_joiner() { + for (auto& thread : m_threads) { + if (thread.joinable()) { + thread.join(); + } + } + } + + }; // class thread_joiner + + std::atomic m_done; + osmium::thread::Queue m_work_queue; + std::vector m_threads; + thread_joiner m_joiner; + int m_num_threads; + + void worker_thread() { + osmium::thread::set_thread_name("_osmium_worker"); + while (!m_done) { + function_wrapper task; + m_work_queue.wait_and_pop_with_timeout(task); + if (task) { + task(); + } + } + } + + /** + * Create thread pool with the given number of threads. If + * num_threads is 0, the number of threads is read from + * the environment variable OSMIUM_POOL_THREADS. The default + * value in that case is -2. + * + * If the number of threads is a negative number, it will be + * set to the actual number of cores on the system plus the + * given number, ie it will leave a number of cores unused. + * + * In all cases the minimum number of threads in the pool is 1. + */ + explicit Pool(int num_threads) : + m_done(false), + m_work_queue(), + m_threads(), + m_joiner(m_threads), + m_num_threads(num_threads) { + + if (m_num_threads == 0) { + const char* env_threads = getenv("OSMIUM_POOL_THREADS"); + if (env_threads) { + m_num_threads = std::atoi(env_threads); + } else { + m_num_threads = -2; + } + } + + if (m_num_threads <= 0) { + m_num_threads = std::max(1, static_cast(std::thread::hardware_concurrency()) + m_num_threads); + } + + try { + for (int i=0; i < m_num_threads; ++i) { + m_threads.push_back(std::thread(&Pool::worker_thread, this)); + } + } catch (...) { + m_done = true; + throw; + } + } + + public: + + static constexpr int default_num_threads = 0; + + static Pool& instance() { + static Pool pool(default_num_threads); + return pool; + } + + ~Pool() { + m_done = true; + } + + size_t queue_size() const { + return m_work_queue.size(); + } + + bool queue_empty() const { + return m_work_queue.empty(); + } + + template + std::future::type> submit(TFunction f) { + + typedef typename std::result_of::type result_type; + + std::packaged_task task(std::move(f)); + std::future future_result(task.get_future()); + m_work_queue.push(std::move(task)); + + return future_result; + } + + }; // class Pool + + } // namespace thread + +} // namespace osmium + +#endif // OSMIUM_THREAD_POOL_HPP diff --git a/ThirdParty/osmium/thread/queue.hpp b/ThirdParty/osmium/thread/queue.hpp new file mode 100644 index 000000000..633177e74 --- /dev/null +++ b/ThirdParty/osmium/thread/queue.hpp @@ -0,0 +1,128 @@ +#ifndef OSMIUM_THREAD_QUEUE_HPP +#define OSMIUM_THREAD_QUEUE_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include +#include +#include + +namespace osmium { + + namespace thread { + + /** + * A thread-safe queue. + */ + template + class Queue { + + mutable std::mutex m_mutex; + std::queue m_queue; + std::condition_variable m_data_available; + + public: + + Queue() : + m_mutex(), + m_queue(), + m_data_available() { + } + + void push(T value) { + std::lock_guard lock(m_mutex); + m_queue.push(std::move(value)); + m_data_available.notify_one(); + } + + size_t push_and_get_size(T&& value) { + std::lock_guard lock(m_mutex); + m_queue.push(std::forward(value)); + m_data_available.notify_one(); + return m_queue.size(); + } + + void push(T value, int) { + push(value); + } + + void wait_and_pop(T& value) { + std::unique_lock lock(m_mutex); + m_data_available.wait(lock, [this] { + return !m_queue.empty(); + }); + value=std::move(m_queue.front()); + m_queue.pop(); + } + + void wait_and_pop_with_timeout(T& value) { + std::unique_lock lock(m_mutex); + if (!m_data_available.wait_for(lock, std::chrono::seconds(1), [this] { + return !m_queue.empty(); + })) { + return; + } + value=std::move(m_queue.front()); + m_queue.pop(); + } + + bool try_pop(T& value) { + std::lock_guard lock(m_mutex); + if (m_queue.empty()) { + return false; + } + value=std::move(m_queue.front()); + m_queue.pop(); + return true; + } + + bool empty() const { + std::lock_guard lock(m_mutex); + return m_queue.empty(); + } + + size_t size() const { + std::lock_guard lock(m_mutex); + return m_queue.size(); + } + + }; // class Queue + + } // namespace thread + +} // namespace osmium + +#endif // OSMIUM_THREAD_QUEUE_HPP diff --git a/ThirdParty/osmium/thread/sorted_queue.hpp b/ThirdParty/osmium/thread/sorted_queue.hpp new file mode 100644 index 000000000..e33dfe696 --- /dev/null +++ b/ThirdParty/osmium/thread/sorted_queue.hpp @@ -0,0 +1,159 @@ +#ifndef OSMIUM_THREAD_SORTED_QUEUE_HPP +#define OSMIUM_THREAD_SORTED_QUEUE_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include + +namespace osmium { + + namespace thread { + + /** + * This implements a sorted queue. It is a bit like a priority + * queue. We have n worker threads pushing items into the queue + * and one thread pulling them out again "in order". The order + * is defined by the monotonically increasing "num" parameter + * to the push() method. The wait_and_pop() and try_pop() methods + * will only give out the next numbered item. This way several + * workers can work in their own time on different pieces of + * some incoming data, but it all gets serialized properly again + * after the workers have done their work. + */ + template + class SortedQueue { + + typedef typename std::deque::size_type size_type; + + mutable std::mutex m_mutex; + std::deque m_queue; + std::condition_variable m_data_available; + + size_type m_offset; + + // this method expects that we already have the lock + bool empty_intern() const { + return m_queue.front() == T(); + } + + public: + + SortedQueue() : + m_mutex(), + m_queue(1), + m_data_available(), + m_offset(0) { + } + + /** + * Push an item into the queue. + * + * @param value The item to push into the queue. + * @param num Number to describe ordering for the items. + * It must increase monotonically. + */ + void push(T value, size_type num) { + std::lock_guard lock(m_mutex); + + num -= m_offset; + if (m_queue.size() <= num + 1) { + m_queue.resize(num + 2); + } + m_queue[num] = std::move(value); + + m_data_available.notify_one(); + } + + /** + * Wait until the next item becomes available and make it + * available through value. + */ + void wait_and_pop(T& value) { + std::unique_lock lock(m_mutex); + + m_data_available.wait(lock, [this] { + return !empty_intern(); + }); + value=std::move(m_queue.front()); + m_queue.pop_front(); + ++m_offset; + } + + /** + * Get next item if it is available and return true. Or + * return false otherwise. + */ + bool try_pop(T& value) { + std::lock_guard lock(m_mutex); + + if (empty_intern()) { + return false; + } + value=std::move(m_queue.front()); + m_queue.pop_front(); + ++m_offset; + return true; + } + + /** + * The queue is empty. This means try_pop() would fail if called. + * It does not mean that there is nothing on the queue. Because + * the queue is sorted, it could mean that the next item in the + * queue is not available, but other items are. + */ + bool empty() const { + std::lock_guard lock(m_mutex); + + return empty_intern(); + } + + /** + * Returns the number of items in the queue, regardless of whether + * they can be accessed. If this is =0 it + * implies empty()==true, but not the other way around. + */ + size_t size() const { + std::lock_guard lock(m_mutex); + return m_queue.size(); + } + + }; // class SortedQueue + + } // namespace thread + +} // namespace osmium + +#endif // OSMIUM_THREAD_SORTED_QUEUE_HPP diff --git a/ThirdParty/osmium/util/compatibility.hpp b/ThirdParty/osmium/util/compatibility.hpp new file mode 100644 index 000000000..dfd854cc3 --- /dev/null +++ b/ThirdParty/osmium/util/compatibility.hpp @@ -0,0 +1,47 @@ +#ifndef OSMIUM_CONFIG_CONSTEXPR_HPP +#define OSMIUM_CONFIG_CONSTEXPR_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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. + +*/ + +// Workarounds for MSVC which doesn't support +// * constexpr in all cases yet +// * [[noreturn]] +#ifdef _MSC_VER +# define OSMIUM_CONSTEXPR +# define OSMIUM_NORETURN __declspec(noreturn) +#else +# define OSMIUM_CONSTEXPR constexpr +# define OSMIUM_NORETURN [[noreturn]] +#endif + +#endif // OSMIUM_CONFIG_CONSTEXPR_HPP diff --git a/ThirdParty/osmium/util/options.hpp b/ThirdParty/osmium/util/options.hpp new file mode 100644 index 000000000..fc74980d1 --- /dev/null +++ b/ThirdParty/osmium/util/options.hpp @@ -0,0 +1,155 @@ +#ifndef OSMIUM_UTIL_OPTIONS_HPP +#define OSMIUM_UTIL_OPTIONS_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include + +namespace osmium { + + namespace util { + + /** + * Stores key=value type options. This class can be used stand-alone or + * as a base class. Options are stored and retrieved by key using the + * different set() and get() methods. + * + * You can iterate over all set options. Dereferencing an iterator + * yields a std::pair of the key and value strings. + */ + class Options { + + typedef std::map option_map; + option_map m_options; + + public: + + typedef option_map::iterator iterator; + typedef option_map::const_iterator const_iterator; + typedef option_map::value_type value_type; + + Options() = default; + + explicit Options(const std::initializer_list& values) : + m_options(values) { + } + + Options(const Options&) = default; + Options& operator=(const Options&) = default; + + Options(Options&&) = default; + Options& operator=(Options&&) = default; + + ~Options() = default; + + void set(const std::string& key, const std::string& value) { + m_options[key] = value; + } + + void set(const std::string& key, const char* value) { + m_options[key] = value; + } + + void set(const std::string& key, bool value) { + m_options[key] = value ? "true" : "false"; + } + + void set(std::string data) { + size_t pos = data.find_first_of('='); + if (pos == std::string::npos) { + m_options[data] = "true"; + } else { + std::string value = data.substr(pos+1); + data.erase(pos); + set(data, value); + } + } + + /** + * Get value of "key" option. If not set the default_value (or + * empty string) is returned. + */ + std::string get(const std::string& key, const std::string& default_value="") const noexcept { + auto it = m_options.find(key); + if (it == m_options.end()) { + return default_value; + } + return it->second; + } + + /** + * Is this option set to a true value ("true" or "yes")? + */ + bool is_true(const std::string& key) const noexcept { + std::string value = get(key); + return (value == "true" || value == "yes"); + } + + size_t size() const noexcept { + return m_options.size(); + } + + iterator begin() noexcept { + return m_options.begin(); + } + + iterator end() noexcept { + return m_options.end(); + } + + const_iterator begin() const noexcept { + return m_options.cbegin(); + } + + const_iterator end() const noexcept { + return m_options.cend(); + } + + const_iterator cbegin() const noexcept { + return m_options.cbegin(); + } + + const_iterator cend() const noexcept { + return m_options.cend(); + } + + }; // class Options + + } // namespace util + +} // namespace osmium + +#endif // OSMIUM_UTIL_OPTIONS_HPP diff --git a/ThirdParty/osmium/util/verbose_output.hpp b/ThirdParty/osmium/util/verbose_output.hpp new file mode 100644 index 000000000..9925ceee4 --- /dev/null +++ b/ThirdParty/osmium/util/verbose_output.hpp @@ -0,0 +1,139 @@ +#ifndef OSMIUM_UTIL_VERBOSE_OUTPUT_HPP +#define OSMIUM_UTIL_VERBOSE_OUTPUT_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 + +#include +#include +#include + +namespace osmium { + + /** + * @brief Helpful utility classes and functions not strictly OSM related + */ + namespace util { + + /** + * Osmium programs often run for a long time because of the amount of + * OSM data processed. This class helps with keeping the user up to + * date by offering an easy way for programs to optionally output + * verbose information about what's going on. + * + * Use an object of this class instead of std::cerr as an output + * stream. Nothing is actually written if the object is not set to + * verbose mode. If it is set to verbose mode, each line is prepended + * with the running time, ie the time since the VerboseOutput object + * was created. + */ + class VerboseOutput { + + /// all time output will be relative to this start time + time_t m_start; + + /// is verbose mode enabled? + bool m_verbose; + + /// a newline was written, start next output with runtime + bool m_newline; + + /** + * If we remember that a newline was written as the last thing + * write out the time elapsed and reset the newline flag. + */ + void start_line() { + if (m_newline) { + time_t elapsed = runtime(); + + char old_fill = std::cerr.fill(); + std::cerr << '[' << std::setw(2) << (elapsed / 60) << ':' << std::setw(2) << std::setfill('0') << (elapsed % 60) << "] "; + std::cerr.fill(old_fill); + + m_newline = false; + } + } + + public: + + explicit VerboseOutput(bool verbose=false) : + m_start(time(NULL)), + m_verbose(verbose), + m_newline(true) { + } + + ~VerboseOutput() = default; + + VerboseOutput(const VerboseOutput&) = default; + VerboseOutput& operator=(const VerboseOutput&) = default; + VerboseOutput(VerboseOutput&&) = default; + VerboseOutput& operator=(VerboseOutput&&) = default; + + time_t runtime() const noexcept { + return time(NULL) - m_start; + } + + /// Get "verbose" setting. + bool verbose() const noexcept { + return m_verbose; + } + + /// Set "verbose" setting. + void verbose(bool verbose) noexcept { + m_verbose = verbose; + } + + template + friend VerboseOutput& operator<<(VerboseOutput& verbose_output, const T& value) { + if (verbose_output.m_verbose) { + verbose_output.start_line(); + std::cerr << value; + + // check if there was a newline a the end and remember that + std::ostringstream output_buffer; + output_buffer << value; + if (!output_buffer.str().empty() && output_buffer.str().back() == '\n') { + verbose_output.m_newline = true; + } + } + return verbose_output; + } + + }; // class VerboseOutput + + } // namespace util + +} // namespace osmium + +#endif // OSMIUM_UTIL_VERBOSE_OUTPUT_HPP diff --git a/ThirdParty/osmium/visitor.hpp b/ThirdParty/osmium/visitor.hpp new file mode 100644 index 000000000..e7d97b0fc --- /dev/null +++ b/ThirdParty/osmium/visitor.hpp @@ -0,0 +1,255 @@ +#ifndef OSMIUM_VISITOR_HPP +#define OSMIUM_VISITOR_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 + +#include // IWYU pragma: keep +#include +#include +#include +#include + +namespace osmium { + + class TagList; + class WayNodeList; + class RelationMemberList; + class OuterRing; + class InnerRing; + + namespace memory { + class Item; + } + + namespace detail { + + template + using ConstIfConst = typename std::conditional::value, typename std::add_const::type, U>::type; + + template + inline void apply_item_recurse(TItem& item, THandler& handler) { + switch (item.type()) { + case osmium::item_type::undefined: + break; + case osmium::item_type::node: + handler.osm_object(static_cast&>(item)); + handler.node(static_cast&>(item)); + break; + case osmium::item_type::way: + handler.osm_object(static_cast&>(item)); + handler.way(static_cast&>(item)); + break; + case osmium::item_type::relation: + handler.osm_object(static_cast&>(item)); + handler.relation(static_cast&>(item)); + break; + case osmium::item_type::area: + handler.osm_object(static_cast&>(item)); + handler.area(static_cast&>(item)); + break; + case osmium::item_type::changeset: + handler.changeset(static_cast&>(item)); + break; + case osmium::item_type::tag_list: + handler.tag_list(static_cast&>(item)); + break; + case osmium::item_type::way_node_list: + handler.way_node_list(static_cast&>(item)); + break; + case osmium::item_type::relation_member_list: + case osmium::item_type::relation_member_list_with_full_members: + handler.relation_member_list(static_cast&>(item)); + break; + case osmium::item_type::outer_ring: + handler.outer_ring(static_cast&>(item)); + break; + case osmium::item_type::inner_ring: + handler.inner_ring(static_cast&>(item)); + break; + } + } + + template + inline void apply_item_recurse(const osmium::OSMEntity& item, THandler& handler) { + switch (item.type()) { + case osmium::item_type::node: + handler.osm_object(static_cast(item)); + handler.node(static_cast(item)); + break; + case osmium::item_type::way: + handler.osm_object(static_cast(item)); + handler.way(static_cast(item)); + break; + case osmium::item_type::relation: + handler.osm_object(static_cast(item)); + handler.relation(static_cast(item)); + break; + case osmium::item_type::area: + handler.osm_object(static_cast(item)); + handler.area(static_cast(item)); + break; + case osmium::item_type::changeset: + handler.changeset(static_cast(item)); + break; + default: + throw osmium::unknown_type(); + } + } + + template + inline void apply_item_recurse(osmium::OSMEntity& item, THandler& handler) { + switch (item.type()) { + case osmium::item_type::node: + handler.osm_object(static_cast(item)); + handler.node(static_cast(item)); + break; + case osmium::item_type::way: + handler.osm_object(static_cast(item)); + handler.way(static_cast(item)); + break; + case osmium::item_type::relation: + handler.osm_object(static_cast(item)); + handler.relation(static_cast(item)); + break; + case osmium::item_type::area: + handler.osm_object(static_cast(item)); + handler.area(static_cast(item)); + break; + case osmium::item_type::changeset: + handler.changeset(static_cast(item)); + break; + default: + throw osmium::unknown_type(); + } + } + + template + inline void apply_item_recurse(const osmium::OSMObject& item, THandler& handler) { + switch (item.type()) { + case osmium::item_type::node: + handler.osm_object(item); + handler.node(static_cast(item)); + break; + case osmium::item_type::way: + handler.osm_object(item); + handler.way(static_cast(item)); + break; + case osmium::item_type::relation: + handler.osm_object(item); + handler.relation(static_cast(item)); + break; + case osmium::item_type::area: + handler.osm_object(item); + handler.area(static_cast(item)); + break; + default: + throw osmium::unknown_type(); + } + } + + template + inline void apply_item_recurse(osmium::OSMObject& item, THandler& handler) { + switch (item.type()) { + case osmium::item_type::node: + handler.osm_object(item); + handler.node(static_cast(item)); + break; + case osmium::item_type::way: + handler.osm_object(item); + handler.way(static_cast(item)); + break; + case osmium::item_type::relation: + handler.osm_object(item); + handler.relation(static_cast(item)); + break; + case osmium::item_type::area: + handler.osm_object(item); + handler.area(static_cast(item)); + break; + default: + throw osmium::unknown_type(); + } + } + + template + inline void apply_item_recurse(TItem& item, THandler& handler, TRest&... more) { + apply_item_recurse(item, handler); + apply_item_recurse(item, more...); + } + + template + inline void flush_recurse(THandler& handler) { + handler.flush(); + } + + template + inline void flush_recurse(THandler& handler, TRest&... more) { + flush_recurse(handler); + flush_recurse(more...); + } + + } // namespace detail + + template + inline void apply_item(const osmium::memory::Item& item, THandlers&... handlers) { + detail::apply_item_recurse(item, handlers...); + } + + template + inline void apply_item(osmium::memory::Item& item, THandlers&... handlers) { + detail::apply_item_recurse(item, handlers...); + } + + template + inline void apply(TIterator it, TIterator end, THandlers&... handlers) { + for (; it != end; ++it) { + detail::apply_item_recurse(*it, handlers...); + } + detail::flush_recurse(handlers...); + } + + template + inline void apply(TContainer& c, THandlers&... handlers) { + apply(std::begin(c), std::end(c), handlers...); + } + + template + inline void apply(const osmium::memory::Buffer& buffer, THandlers&... handlers) { + apply(buffer.cbegin(), buffer.cend(), handlers...); + } + +} // namespace osmium + +#endif // OSMIUM_VISITOR_HPP From 0a2898da17a7313f7a58e72b119536319d3f1d8e Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Tue, 26 Aug 2014 16:04:40 +0200 Subject: [PATCH 02/80] remove legacy extrators --- Extractor/PBFParser.cpp | 665 ---------------------------------------- Extractor/PBFParser.h | 103 ------- Extractor/XMLParser.cpp | 354 --------------------- Extractor/XMLParser.h | 54 ---- 4 files changed, 1176 deletions(-) delete mode 100644 Extractor/PBFParser.cpp delete mode 100644 Extractor/PBFParser.h delete mode 100644 Extractor/XMLParser.cpp delete mode 100644 Extractor/XMLParser.h diff --git a/Extractor/PBFParser.cpp b/Extractor/PBFParser.cpp deleted file mode 100644 index fd489533f..000000000 --- a/Extractor/PBFParser.cpp +++ /dev/null @@ -1,665 +0,0 @@ -/* - -Copyright (c) 2013, Project OSRM, Dennis Luxen, others -All rights reserved. - -Redistribution and use in source and binary forms, with or without modification, -are permitted provided that the following conditions are met: - -Redistributions of source code must retain the above copyright notice, this list -of conditions and the following disclaimer. -Redistributions in binary form must reproduce the above copyright notice, this -list of conditions and the following disclaimer in the documentation and/or -other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON -ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -*/ - -#include "PBFParser.h" - -#include "ExtractionWay.h" -#include "ExtractorCallbacks.h" -#include "ScriptingEnvironment.h" - -#include "../DataStructures/HashTable.h" -#include "../DataStructures/ImportNode.h" -#include "../DataStructures/Restriction.h" -#include "../Util/MachineInfo.h" -#include "../Util/OSRMException.h" -#include "../Util/simple_logger.hpp" -#include "../typedefs.h" - -#include - -#include -#include - -#include - -#include - -#include -#include -#include -#include - -PBFParser::PBFParser(const char *fileName, - ExtractorCallbacks *extractor_callbacks, - ScriptingEnvironment &scripting_environment, - unsigned num_threads) - : BaseParser(extractor_callbacks, scripting_environment) -{ - if (0 == num_threads) - { - num_parser_threads = tbb::task_scheduler_init::default_num_threads(); - } - else - { - num_parser_threads = num_threads; - } - - GOOGLE_PROTOBUF_VERIFY_VERSION; - // TODO: What is the bottleneck here? Filling the queue or reading the stuff from disk? - // NOTE: With Lua scripting, it is parsing the stuff. I/O is virtually for free. - - // Max 2500 items in queue, hardcoded. - thread_data_queue = std::make_shared>(2500); - input.open(fileName, std::ios::in | std::ios::binary); - - if (!input) - { - throw OSRMException("pbf file not found."); - } - - block_count = 0; - group_count = 0; -} - -PBFParser::~PBFParser() -{ - if (input.is_open()) - { - input.close(); - } - - // Clean up any leftover ThreadData objects in the queue - ParserThreadData *thread_data; - while (thread_data_queue->try_pop(thread_data)) - { - delete thread_data; - } - google::protobuf::ShutdownProtobufLibrary(); - - SimpleLogger().Write(logDEBUG) << "parsed " << block_count << " blocks from pbf with " - << group_count << " groups"; -} - -inline bool PBFParser::ReadHeader() -{ - ParserThreadData init_data; - /** read Header */ - if (!readPBFBlobHeader(input, &init_data)) - { - return false; - } - - if (readBlob(input, &init_data)) - { - if (!init_data.PBFHeaderBlock.ParseFromArray(&(init_data.charBuffer[0]), - static_cast(init_data.charBuffer.size()))) - { - std::cerr << "[error] Header not parseable!" << std::endl; - return false; - } - - const auto feature_size = init_data.PBFHeaderBlock.required_features_size(); - for (int i = 0; i < feature_size; ++i) - { - const std::string &feature = init_data.PBFHeaderBlock.required_features(i); - bool supported = false; - if ("OsmSchema-V0.6" == feature) - { - supported = true; - } - else if ("DenseNodes" == feature) - { - supported = true; - } - - if (!supported) - { - std::cerr << "[error] required feature not supported: " << feature.data() - << std::endl; - return false; - } - } - } - else - { - std::cerr << "[error] blob not loaded!" << std::endl; - } - return true; -} - -inline void PBFParser::ReadData() -{ - bool keep_running = true; - do - { - ParserThreadData *thread_data = new ParserThreadData(); - keep_running = readNextBlock(input, thread_data); - - if (keep_running) - { - thread_data_queue->push(thread_data); - } - else - { - // No more data to read, parse stops when nullptr encountered - thread_data_queue->push(nullptr); - delete thread_data; - } - } while (keep_running); -} - -inline void PBFParser::ParseData() -{ - tbb::task_scheduler_init init(num_parser_threads); - - while (true) - { - ParserThreadData *thread_data; - thread_data_queue->wait_and_pop(thread_data); - if (nullptr == thread_data) - { - thread_data_queue->push(nullptr); // Signal end of data for other threads - break; - } - - loadBlock(thread_data); - - int group_size = thread_data->PBFprimitiveBlock.primitivegroup_size(); - for (int i = 0; i < group_size; ++i) - { - thread_data->currentGroupID = i; - loadGroup(thread_data); - - if (thread_data->entityTypeIndicator == TypeNode) - { - parseNode(thread_data); - } - if (thread_data->entityTypeIndicator == TypeWay) - { - parseWay(thread_data); - } - if (thread_data->entityTypeIndicator == TypeRelation) - { - parseRelation(thread_data); - } - if (thread_data->entityTypeIndicator == TypeDenseNode) - { - parseDenseNode(thread_data); - } - } - - delete thread_data; - thread_data = nullptr; - } -} - -inline bool PBFParser::Parse() -{ - // Start the read and parse threads - std::thread read_thread(std::bind(&PBFParser::ReadData, this)); - - // Open several parse threads that are synchronized before call to - std::thread parse_thread(std::bind(&PBFParser::ParseData, this)); - - // Wait for the threads to finish - read_thread.join(); - parse_thread.join(); - - return true; -} - -inline void PBFParser::parseDenseNode(ParserThreadData *thread_data) -{ - const OSMPBF::DenseNodes &dense = - thread_data->PBFprimitiveBlock.primitivegroup(thread_data->currentGroupID).dense(); - int denseTagIndex = 0; - int64_t m_lastDenseID = 0; - int64_t m_lastDenseLatitude = 0; - int64_t m_lastDenseLongitude = 0; - - const int number_of_nodes = dense.id_size(); - std::vector extracted_nodes_vector(number_of_nodes); - for (int i = 0; i < number_of_nodes; ++i) - { - m_lastDenseID += dense.id(i); - m_lastDenseLatitude += dense.lat(i); - m_lastDenseLongitude += dense.lon(i); - extracted_nodes_vector[i].node_id = static_cast(m_lastDenseID); - extracted_nodes_vector[i].lat = static_cast( - COORDINATE_PRECISION * - ((double)m_lastDenseLatitude * thread_data->PBFprimitiveBlock.granularity() + - thread_data->PBFprimitiveBlock.lat_offset()) / - NANO); - extracted_nodes_vector[i].lon = static_cast( - COORDINATE_PRECISION * - ((double)m_lastDenseLongitude * thread_data->PBFprimitiveBlock.granularity() + - thread_data->PBFprimitiveBlock.lon_offset()) / - NANO); - while (denseTagIndex < dense.keys_vals_size()) - { - const int tagValue = dense.keys_vals(denseTagIndex); - if (0 == tagValue) - { - ++denseTagIndex; - break; - } - const int keyValue = dense.keys_vals(denseTagIndex + 1); - const std::string &key = thread_data->PBFprimitiveBlock.stringtable().s(tagValue); - const std::string &value = thread_data->PBFprimitiveBlock.stringtable().s(keyValue); - extracted_nodes_vector[i].keyVals.Add(std::move(key), std::move(value)); - denseTagIndex += 2; - } - } - - tbb::parallel_for(tbb::blocked_range(0, extracted_nodes_vector.size()), - [this, &extracted_nodes_vector](const tbb::blocked_range &range) - { - lua_State *lua_state = this->scripting_environment.getLuaState(); - for (size_t i = range.begin(); i != range.end(); ++i) - { - ImportNode &import_node = extracted_nodes_vector[i]; - ParseNodeInLua(import_node, lua_state); - } - }); - - for (const ImportNode &import_node : extracted_nodes_vector) - { - extractor_callbacks->ProcessNode(import_node); - } -} - -inline void PBFParser::parseNode(ParserThreadData *) -{ - throw OSRMException("Parsing of simple nodes not supported. PBF should use dense nodes"); -} - -inline void PBFParser::parseRelation(ParserThreadData *thread_data) -{ - // TODO: leave early, if relation is not a restriction - // TODO: reuse rawRestriction container - if (!use_turn_restrictions) - { - return; - } - const OSMPBF::PrimitiveGroup &group = - thread_data->PBFprimitiveBlock.primitivegroup(thread_data->currentGroupID); - - for (int i = 0, relation_size = group.relations_size(); i < relation_size; ++i) - { - std::string except_tag_string; - const OSMPBF::Relation &inputRelation = - thread_data->PBFprimitiveBlock.primitivegroup(thread_data->currentGroupID).relations(i); - bool is_restriction = false; - bool is_only_restriction = false; - for (int k = 0, endOfKeys = inputRelation.keys_size(); k < endOfKeys; ++k) - { - const std::string &key = - thread_data->PBFprimitiveBlock.stringtable().s(inputRelation.keys(k)); - const std::string &val = - thread_data->PBFprimitiveBlock.stringtable().s(inputRelation.vals(k)); - if ("type" == key) - { - if ("restriction" == val) - { - is_restriction = true; - } - else - { - break; - } - } - if (("restriction" == key) && (val.find("only_") == 0)) - { - is_only_restriction = true; - } - if ("except" == key) - { - except_tag_string = val; - } - } - - if (is_restriction && ShouldIgnoreRestriction(except_tag_string)) - { - continue; - } - - if (is_restriction) - { - int64_t last_ref = 0; - InputRestrictionContainer current_restriction_container(is_only_restriction); - for (int rolesIndex = 0, last_role = inputRelation.roles_sid_size(); - rolesIndex < last_role; - ++rolesIndex) - { - const std::string &role = thread_data->PBFprimitiveBlock.stringtable().s( - inputRelation.roles_sid(rolesIndex)); - last_ref += inputRelation.memids(rolesIndex); - - if (!("from" == role || "to" == role || "via" == role)) - { - continue; - } - - switch (inputRelation.types(rolesIndex)) - { - case 0: // node - if ("from" == role || "to" == role) - { // Only via should be a node - continue; - } - BOOST_ASSERT("via" == role); - if (std::numeric_limits::max() != - current_restriction_container.viaNode) - { - current_restriction_container.viaNode = - std::numeric_limits::max(); - } - BOOST_ASSERT(std::numeric_limits::max() == - current_restriction_container.viaNode); - current_restriction_container.restriction.viaNode = - static_cast(last_ref); - break; - case 1: // way - BOOST_ASSERT("from" == role || "to" == role || "via" == role); - if ("from" == role) - { - current_restriction_container.fromWay = static_cast(last_ref); - } - if ("to" == role) - { - current_restriction_container.toWay = static_cast(last_ref); - } - if ("via" == role) - { - BOOST_ASSERT(current_restriction_container.restriction.toNode == - std::numeric_limits::max()); - current_restriction_container.viaNode = static_cast(last_ref); - } - break; - case 2: // relation, not used. relations relating to relations are evil. - continue; - BOOST_ASSERT(false); - break; - - default: // should not happen - BOOST_ASSERT(false); - break; - } - } - if (!extractor_callbacks->ProcessRestriction(current_restriction_container)) - { - std::cerr << "[PBFParser] relation not parsed" << std::endl; - } - } - } -} - -inline void PBFParser::parseWay(ParserThreadData *thread_data) -{ - const int number_of_ways = - thread_data->PBFprimitiveBlock.primitivegroup(thread_data->currentGroupID).ways_size(); - std::vector parsed_way_vector(number_of_ways); - for (int i = 0; i < number_of_ways; ++i) - { - const OSMPBF::Way &input_way = - thread_data->PBFprimitiveBlock.primitivegroup(thread_data->currentGroupID).ways(i); - parsed_way_vector[i].id = static_cast(input_way.id()); - unsigned node_id_in_path = 0; - const auto number_of_referenced_nodes = input_way.refs_size(); - for (auto j = 0; j < number_of_referenced_nodes; ++j) - { - node_id_in_path += static_cast(input_way.refs(j)); - parsed_way_vector[i].path.push_back(node_id_in_path); - } - BOOST_ASSERT(input_way.keys_size() == input_way.vals_size()); - const auto number_of_keys = input_way.keys_size(); - for (auto j = 0; j < number_of_keys; ++j) - { - const std::string &key = - thread_data->PBFprimitiveBlock.stringtable().s(input_way.keys(j)); - const std::string &val = - thread_data->PBFprimitiveBlock.stringtable().s(input_way.vals(j)); - parsed_way_vector[i].keyVals.Add(std::move(key), std::move(val)); - } - } - - // TODO: investigate if schedule guided will be handled by tbb automatically - tbb::parallel_for(tbb::blocked_range(0, parsed_way_vector.size()), - [this, &parsed_way_vector](const tbb::blocked_range &range) - { - lua_State *lua_state = this->scripting_environment.getLuaState(); - for (size_t i = range.begin(); i != range.end(); i++) - { - ExtractionWay &extraction_way = parsed_way_vector[i]; - if (2 <= extraction_way.path.size()) - { - ParseWayInLua(extraction_way, lua_state); - } - } - }); - - for (ExtractionWay &extraction_way : parsed_way_vector) - { - if (2 <= extraction_way.path.size()) - { - extractor_callbacks->ProcessWay(extraction_way); - } - } -} - -inline void PBFParser::loadGroup(ParserThreadData *thread_data) -{ -#ifndef NDEBUG - ++group_count; -#endif - - const OSMPBF::PrimitiveGroup &group = - thread_data->PBFprimitiveBlock.primitivegroup(thread_data->currentGroupID); - thread_data->entityTypeIndicator = TypeDummy; - if (0 != group.nodes_size()) - { - thread_data->entityTypeIndicator = TypeNode; - } - if (0 != group.ways_size()) - { - thread_data->entityTypeIndicator = TypeWay; - } - if (0 != group.relations_size()) - { - thread_data->entityTypeIndicator = TypeRelation; - } - if (group.has_dense()) - { - thread_data->entityTypeIndicator = TypeDenseNode; - BOOST_ASSERT(0 != group.dense().id_size()); - } - BOOST_ASSERT(thread_data->entityTypeIndicator != TypeDummy); -} - -inline void PBFParser::loadBlock(ParserThreadData *thread_data) -{ - ++block_count; - thread_data->currentGroupID = 0; - thread_data->currentEntityID = 0; -} - -inline bool PBFParser::readPBFBlobHeader(std::fstream &stream, ParserThreadData *thread_data) -{ - int size(0); - stream.read((char *)&size, sizeof(int)); - size = SwapEndian(size); - if (stream.eof()) - { - return false; - } - if (size > MAX_BLOB_HEADER_SIZE || size < 0) - { - return false; - } - char *data = new char[size]; - stream.read(data, size * sizeof(data[0])); - - bool dataSuccessfullyParsed = (thread_data->PBFBlobHeader).ParseFromArray(data, size); - delete[] data; - return dataSuccessfullyParsed; -} - -inline bool PBFParser::unpackZLIB(ParserThreadData *thread_data) -{ - auto raw_size = thread_data->PBFBlob.raw_size(); - char *unpacked_data_array = new char[raw_size]; - z_stream compressed_data_stream; - compressed_data_stream.next_in = (unsigned char *)thread_data->PBFBlob.zlib_data().data(); - compressed_data_stream.avail_in = thread_data->PBFBlob.zlib_data().size(); - compressed_data_stream.next_out = (unsigned char *)unpacked_data_array; - compressed_data_stream.avail_out = raw_size; - compressed_data_stream.zalloc = Z_NULL; - compressed_data_stream.zfree = Z_NULL; - compressed_data_stream.opaque = Z_NULL; - int return_code = inflateInit(&compressed_data_stream); - if (return_code != Z_OK) - { - std::cerr << "[error] failed to init zlib stream" << std::endl; - delete[] unpacked_data_array; - return false; - } - - return_code = inflate(&compressed_data_stream, Z_FINISH); - if (return_code != Z_STREAM_END) - { - std::cerr << "[error] failed to inflate zlib stream" << std::endl; - std::cerr << "[error] Error type: " << return_code << std::endl; - delete[] unpacked_data_array; - return false; - } - - return_code = inflateEnd(&compressed_data_stream); - if (return_code != Z_OK) - { - std::cerr << "[error] failed to deinit zlib stream" << std::endl; - delete[] unpacked_data_array; - return false; - } - - thread_data->charBuffer.clear(); - thread_data->charBuffer.resize(raw_size); - std::copy(unpacked_data_array, unpacked_data_array + raw_size, thread_data->charBuffer.begin()); - delete[] unpacked_data_array; - return true; -} - -inline bool PBFParser::unpackLZMA(ParserThreadData *) { return false; } - -inline bool PBFParser::readBlob(std::fstream &stream, ParserThreadData *thread_data) -{ - if (stream.eof()) - { - return false; - } - - const int size = thread_data->PBFBlobHeader.datasize(); - if (size < 0 || size > MAX_BLOB_SIZE) - { - std::cerr << "[error] invalid Blob size:" << size << std::endl; - return false; - } - - char *data = new char[size]; - stream.read(data, sizeof(data[0]) * size); - - if (!thread_data->PBFBlob.ParseFromArray(data, size)) - { - std::cerr << "[error] failed to parse blob" << std::endl; - delete[] data; - return false; - } - - if (thread_data->PBFBlob.has_raw()) - { - const std::string &data = thread_data->PBFBlob.raw(); - thread_data->charBuffer.clear(); - thread_data->charBuffer.resize(data.size()); - std::copy(data.begin(), data.end(), thread_data->charBuffer.begin()); - } - else if (thread_data->PBFBlob.has_zlib_data()) - { - if (!unpackZLIB(thread_data)) - { - std::cerr << "[error] zlib data encountered that could not be unpacked" << std::endl; - delete[] data; - return false; - } - } - else if (thread_data->PBFBlob.has_lzma_data()) - { - if (!unpackLZMA(thread_data)) - { - std::cerr << "[error] lzma data encountered that could not be unpacked" << std::endl; - } - delete[] data; - return false; - } - else - { - std::cerr << "[error] Blob contains no data" << std::endl; - delete[] data; - return false; - } - delete[] data; - return true; -} - -bool PBFParser::readNextBlock(std::fstream &stream, ParserThreadData *thread_data) -{ - if (stream.eof()) - { - return false; - } - - if (!readPBFBlobHeader(stream, thread_data)) - { - return false; - } - - if (thread_data->PBFBlobHeader.type() != "OSMData") - { - return false; - } - - if (!readBlob(stream, thread_data)) - { - return false; - } - - if (!thread_data->PBFprimitiveBlock.ParseFromArray(&(thread_data->charBuffer[0]), - thread_data->charBuffer.size())) - { - std::cerr << "failed to parse PrimitiveBlock" << std::endl; - return false; - } - return true; -} diff --git a/Extractor/PBFParser.h b/Extractor/PBFParser.h deleted file mode 100644 index c65a29d40..000000000 --- a/Extractor/PBFParser.h +++ /dev/null @@ -1,103 +0,0 @@ -/* - -Copyright (c) 2013, Project OSRM, Dennis Luxen, others -All rights reserved. - -Redistribution and use in source and binary forms, with or without modification, -are permitted provided that the following conditions are met: - -Redistributions of source code must retain the above copyright notice, this list -of conditions and the following disclaimer. -Redistributions in binary form must reproduce the above copyright notice, this -list of conditions and the following disclaimer in the documentation and/or -other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON -ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -*/ - -#ifndef PBFPARSER_H_ -#define PBFPARSER_H_ - -#include "BaseParser.h" -#include "../DataStructures/ConcurrentQueue.h" - -#include -#include - -#include -#include - -class PBFParser : public BaseParser -{ - - enum EntityType - { TypeDummy = 0, - TypeNode = 1, - TypeWay = 2, - TypeRelation = 4, - TypeDenseNode = 8 }; - - struct ParserThreadData - { - int currentGroupID; - int currentEntityID; - EntityType entityTypeIndicator; - - OSMPBF::BlobHeader PBFBlobHeader; - OSMPBF::Blob PBFBlob; - - OSMPBF::HeaderBlock PBFHeaderBlock; - OSMPBF::PrimitiveBlock PBFprimitiveBlock; - - std::vector charBuffer; - }; - - public: - PBFParser(const char *file_name, - ExtractorCallbacks *extractor_callbacks, - ScriptingEnvironment &scripting_environment, - unsigned num_parser_threads = 0); - virtual ~PBFParser(); - - inline bool ReadHeader(); - inline bool Parse(); - - private: - inline void ReadData(); - inline void ParseData(); - inline void parseDenseNode(ParserThreadData *thread_data); - inline void parseNode(ParserThreadData *thread_data); - inline void parseRelation(ParserThreadData *thread_data); - inline void parseWay(ParserThreadData *thread_data); - - inline void loadGroup(ParserThreadData *thread_data); - inline void loadBlock(ParserThreadData *thread_data); - inline bool readPBFBlobHeader(std::fstream &stream, ParserThreadData *thread_data); - inline bool unpackZLIB(ParserThreadData *thread_data); - inline bool unpackLZMA(ParserThreadData *thread_data); - inline bool readBlob(std::fstream &stream, ParserThreadData *thread_data); - inline bool readNextBlock(std::fstream &stream, ParserThreadData *thread_data); - - static const int NANO = 1000 * 1000 * 1000; - static const int MAX_BLOB_HEADER_SIZE = 64 * 1024; - static const int MAX_BLOB_SIZE = 32 * 1024 * 1024; - - unsigned group_count; - unsigned block_count; - - std::fstream input; // the input stream to parse - std::shared_ptr> thread_data_queue; - unsigned num_parser_threads; -}; - -#endif /* PBFPARSER_H_ */ diff --git a/Extractor/XMLParser.cpp b/Extractor/XMLParser.cpp deleted file mode 100644 index a984c76b7..000000000 --- a/Extractor/XMLParser.cpp +++ /dev/null @@ -1,354 +0,0 @@ -/* - -Copyright (c) 2013, Project OSRM, Dennis Luxen, others -All rights reserved. - -Redistribution and use in source and binary forms, with or without modification, -are permitted provided that the following conditions are met: - -Redistributions of source code must retain the above copyright notice, this list -of conditions and the following disclaimer. -Redistributions in binary form must reproduce the above copyright notice, this -list of conditions and the following disclaimer in the documentation and/or -other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON -ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -*/ - -#include "XMLParser.h" - -#include "ExtractionWay.h" -#include "ExtractorCallbacks.h" - -#include "../DataStructures/HashTable.h" -#include "../DataStructures/ImportNode.h" -#include "../DataStructures/InputReaderFactory.h" -#include "../DataStructures/Restriction.h" -#include "../Util/cast.hpp" -#include "../Util/simple_logger.hpp" -#include "../Util/StringUtil.h" -#include "../typedefs.h" - -#include - -XMLParser::XMLParser(const char *filename, - ExtractorCallbacks *extractor_callbacks, - ScriptingEnvironment &scripting_environment) - : BaseParser(extractor_callbacks, scripting_environment) -{ - inputReader = inputReaderFactory(filename); -} - -bool XMLParser::ReadHeader() { return xmlTextReaderRead(inputReader) == 1; } -bool XMLParser::Parse() -{ - while (xmlTextReaderRead(inputReader) == 1) - { - const int type = xmlTextReaderNodeType(inputReader); - - // 1 is Element - if (type != 1) - { - continue; - } - - xmlChar *currentName = xmlTextReaderName(inputReader); - if (currentName == nullptr) - { - continue; - } - - if (xmlStrEqual(currentName, (const xmlChar *)"node") == 1) - { - ImportNode current_node = ReadXMLNode(); - ParseNodeInLua(current_node, lua_state); - extractor_callbacks->ProcessNode(current_node); - } - - if (xmlStrEqual(currentName, (const xmlChar *)"way") == 1) - { - ExtractionWay way = ReadXMLWay(); - ParseWayInLua(way, lua_state); - extractor_callbacks->ProcessWay(way); - } - if (use_turn_restrictions && xmlStrEqual(currentName, (const xmlChar *)"relation") == 1) - { - InputRestrictionContainer current_restriction = ReadXMLRestriction(); - if ((UINT_MAX != current_restriction.fromWay) && - !extractor_callbacks->ProcessRestriction(current_restriction)) - { - std::cerr << "[XMLParser] restriction not parsed" << std::endl; - } - } - xmlFree(currentName); - } - return true; -} - -InputRestrictionContainer XMLParser::ReadXMLRestriction() -{ - - InputRestrictionContainer restriction; - - if (xmlTextReaderIsEmptyElement(inputReader) == 1) - { - return restriction; - } - - std::string except_tag_string; - const int depth = xmlTextReaderDepth(inputReader); - while (xmlTextReaderRead(inputReader) == 1) - { - const int child_type = xmlTextReaderNodeType(inputReader); - if (child_type != 1 && child_type != 15) - { - continue; - } - const int child_depth = xmlTextReaderDepth(inputReader); - xmlChar *child_name = xmlTextReaderName(inputReader); - if (child_name == nullptr) - { - continue; - } - if (depth == child_depth && child_type == 15 && - xmlStrEqual(child_name, (const xmlChar *)"relation") == 1) - { - xmlFree(child_name); - break; - } - if (child_type != 1) - { - xmlFree(child_name); - continue; - } - - if (xmlStrEqual(child_name, (const xmlChar *)"tag") == 1) - { - xmlChar *key = xmlTextReaderGetAttribute(inputReader, (const xmlChar *)"k"); - xmlChar *value = xmlTextReaderGetAttribute(inputReader, (const xmlChar *)"v"); - if (key != nullptr && value != nullptr) - { - if (xmlStrEqual(key, (const xmlChar *)"restriction") && - StringStartsWith((const char *)value, "only_")) - { - restriction.restriction.flags.isOnly = true; - } - if (xmlStrEqual(key, (const xmlChar *)"except")) - { - except_tag_string = (const char *)value; - } - } - - if (key != nullptr) - { - xmlFree(key); - } - if (value != nullptr) - { - xmlFree(value); - } - } - else if (xmlStrEqual(child_name, (const xmlChar *)"member") == 1) - { - xmlChar *ref = xmlTextReaderGetAttribute(inputReader, (const xmlChar *)"ref"); - if (ref != nullptr) - { - xmlChar *role = xmlTextReaderGetAttribute(inputReader, (const xmlChar *)"role"); - xmlChar *type = xmlTextReaderGetAttribute(inputReader, (const xmlChar *)"type"); - - if (xmlStrEqual(role, (const xmlChar *)"to") && - xmlStrEqual(type, (const xmlChar *)"way")) - { - restriction.toWay = cast::string_to_uint((const char *)ref); - } - if (xmlStrEqual(role, (const xmlChar *)"from") && - xmlStrEqual(type, (const xmlChar *)"way")) - { - restriction.fromWay = cast::string_to_uint((const char *)ref); - } - if (xmlStrEqual(role, (const xmlChar *)"via") && - xmlStrEqual(type, (const xmlChar *)"node")) - { - restriction.restriction.viaNode = cast::string_to_uint((const char *)ref); - } - - if (nullptr != type) - { - xmlFree(type); - } - if (nullptr != role) - { - xmlFree(role); - } - if (nullptr != ref) - { - xmlFree(ref); - } - } - } - xmlFree(child_name); - } - - if (ShouldIgnoreRestriction(except_tag_string)) - { - restriction.fromWay = UINT_MAX; // workaround to ignore the restriction - } - return restriction; -} - -ExtractionWay XMLParser::ReadXMLWay() -{ - ExtractionWay way; - if (xmlTextReaderIsEmptyElement(inputReader) == 1) - { - return way; - } - const int depth = xmlTextReaderDepth(inputReader); - while (xmlTextReaderRead(inputReader) == 1) - { - const int child_type = xmlTextReaderNodeType(inputReader); - if (child_type != 1 && child_type != 15) - { - continue; - } - const int child_depth = xmlTextReaderDepth(inputReader); - xmlChar *child_name = xmlTextReaderName(inputReader); - if (child_name == nullptr) - { - continue; - } - - if (depth == child_depth && child_type == 15 && - xmlStrEqual(child_name, (const xmlChar *)"way") == 1) - { - xmlChar *way_id = xmlTextReaderGetAttribute(inputReader, (const xmlChar *)"id"); - way.id = cast::string_to_uint((char *)way_id); - xmlFree(way_id); - xmlFree(child_name); - break; - } - if (child_type != 1) - { - xmlFree(child_name); - continue; - } - - if (xmlStrEqual(child_name, (const xmlChar *)"tag") == 1) - { - xmlChar *key = xmlTextReaderGetAttribute(inputReader, (const xmlChar *)"k"); - xmlChar *value = xmlTextReaderGetAttribute(inputReader, (const xmlChar *)"v"); - - if (key != nullptr && value != nullptr) - { - way.keyVals.Add(std::string((char *)key), std::string((char *)value)); - } - if (key != nullptr) - { - xmlFree(key); - } - if (value != nullptr) - { - xmlFree(value); - } - } - else if (xmlStrEqual(child_name, (const xmlChar *)"nd") == 1) - { - xmlChar *ref = xmlTextReaderGetAttribute(inputReader, (const xmlChar *)"ref"); - if (ref != nullptr) - { - way.path.push_back(cast::string_to_uint((const char *)ref)); - xmlFree(ref); - } - } - xmlFree(child_name); - } - return way; -} - -ImportNode XMLParser::ReadXMLNode() -{ - ImportNode node; - - xmlChar *attribute = xmlTextReaderGetAttribute(inputReader, (const xmlChar *)"lat"); - if (attribute != nullptr) - { - node.lat = static_cast(COORDINATE_PRECISION * cast::string_to_double((const char *)attribute)); - xmlFree(attribute); - } - attribute = xmlTextReaderGetAttribute(inputReader, (const xmlChar *)"lon"); - if (attribute != nullptr) - { - node.lon = static_cast(COORDINATE_PRECISION * cast::string_to_double((const char *)attribute)); - xmlFree(attribute); - } - attribute = xmlTextReaderGetAttribute(inputReader, (const xmlChar *)"id"); - if (attribute != nullptr) - { - node.node_id = cast::string_to_uint((const char *)attribute); - xmlFree(attribute); - } - - if (xmlTextReaderIsEmptyElement(inputReader) == 1) - { - return node; - } - const int depth = xmlTextReaderDepth(inputReader); - while (xmlTextReaderRead(inputReader) == 1) - { - const int child_type = xmlTextReaderNodeType(inputReader); - // 1 = Element, 15 = EndElement - if (child_type != 1 && child_type != 15) - { - continue; - } - const int child_depth = xmlTextReaderDepth(inputReader); - xmlChar *child_name = xmlTextReaderName(inputReader); - if (child_name == nullptr) - { - continue; - } - - if (depth == child_depth && child_type == 15 && - xmlStrEqual(child_name, (const xmlChar *)"node") == 1) - { - xmlFree(child_name); - break; - } - if (child_type != 1) - { - xmlFree(child_name); - continue; - } - - if (xmlStrEqual(child_name, (const xmlChar *)"tag") == 1) - { - xmlChar *key = xmlTextReaderGetAttribute(inputReader, (const xmlChar *)"k"); - xmlChar *value = xmlTextReaderGetAttribute(inputReader, (const xmlChar *)"v"); - if (key != nullptr && value != nullptr) - { - node.keyVals.Add(std::string((char *)(key)), std::string((char *)(value))); - } - if (key != nullptr) - { - xmlFree(key); - } - if (value != nullptr) - { - xmlFree(value); - } - } - - xmlFree(child_name); - } - return node; -} diff --git a/Extractor/XMLParser.h b/Extractor/XMLParser.h deleted file mode 100644 index 178747ae7..000000000 --- a/Extractor/XMLParser.h +++ /dev/null @@ -1,54 +0,0 @@ -/* - -Copyright (c) 2013, Project OSRM, Dennis Luxen, others -All rights reserved. - -Redistribution and use in source and binary forms, with or without modification, -are permitted provided that the following conditions are met: - -Redistributions of source code must retain the above copyright notice, this list -of conditions and the following disclaimer. -Redistributions in binary form must reproduce the above copyright notice, this -list of conditions and the following disclaimer in the documentation and/or -other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON -ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -*/ - -#ifndef XMLPARSER_H_ -#define XMLPARSER_H_ - -#include "BaseParser.h" -#include "../DataStructures/Restriction.h" - -#include - -class ExtractorCallbacks; - -class XMLParser : public BaseParser -{ - public: - XMLParser(const char *filename, - ExtractorCallbacks *extractor_callbacks, - ScriptingEnvironment &scripting_environment); - bool ReadHeader(); - bool Parse(); - - private: - InputRestrictionContainer ReadXMLRestriction(); - ExtractionWay ReadXMLWay(); - ImportNode ReadXMLNode(); - xmlTextReaderPtr inputReader; -}; - -#endif /* XMLPARSER_H_ */ From b18b4072e1d045e635a04412898447d6f8e1a1bd Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Tue, 26 Aug 2014 16:35:43 +0200 Subject: [PATCH 03/80] implement restriction parsing --- Extractor/RestrictionParser.cpp | 231 ++++++++++++++++++++++++++++++++ 1 file changed, 231 insertions(+) create mode 100644 Extractor/RestrictionParser.cpp diff --git a/Extractor/RestrictionParser.cpp b/Extractor/RestrictionParser.cpp new file mode 100644 index 000000000..f3ba4104a --- /dev/null +++ b/Extractor/RestrictionParser.cpp @@ -0,0 +1,231 @@ +/* + +Copyright (c) 2013, Project OSRM, Dennis Luxen, others +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +*/ + +#include "RestrictionParser.h" +#include "ExtractionWay.h" +#include "ScriptingEnvironment.h" + +#include "../DataStructures/ImportNode.h" +#include "../Util/LuaUtil.h" +#include "../Util/OSRMException.h" +#include "../Util/SimpleLogger.h" + +#include +#include +#include +#include + +#include + +RestrictionParser::RestrictionParser(ScriptingEnvironment &scripting_environment) + : lua_state(scripting_environment.getLuaState()), use_turn_restrictions(true) +{ + ReadUseRestrictionsSetting(); + ReadRestrictionExceptions(); +} + +void RestrictionParser::ReadUseRestrictionsSetting() +{ + if (0 == luaL_dostring(lua_state, "return use_turn_restrictions\n")) + { + if (lua_isboolean(lua_state, -1)) + { + use_turn_restrictions = lua_toboolean(lua_state, -1); + } + } + + if (use_turn_restrictions) + { + SimpleLogger().Write() << "Using turn restrictions"; + } + else + { + SimpleLogger().Write() << "Ignoring turn restrictions"; + } +} + +void RestrictionParser::ReadRestrictionExceptions() +{ + if (lua_function_exists(lua_state, "get_exceptions")) + { + // get list of turn restriction exceptions + luabind::call_function( + lua_state, "get_exceptions", boost::ref(restriction_exceptions)); + const unsigned exception_count = restriction_exceptions.size(); + SimpleLogger().Write() << "Found " << exception_count + << " exceptions to turn restrictions:"; + for (const std::string &str : restriction_exceptions) + { + SimpleLogger().Write() << " " << str; + } + } + else + { + SimpleLogger().Write() << "Found no exceptions to turn restrictions"; + } +} + +boost::optional RestrictionParser::TryParse(osmium::Relation &relation) const +{ + // return if turn restrictions should be ignored + if (!use_turn_restrictions) + { + return boost::optional(); + } + + osmium::tags::KeyPrefixFilter filter(false); + filter.add(true, "restriction"); + + const osmium::TagList &tag_list = relation.tags(); + + osmium::tags::KeyPrefixFilter::iterator fi_begin(filter, tag_list.begin(), tag_list.end()); + osmium::tags::KeyPrefixFilter::iterator fi_end(filter, tag_list.end(), tag_list.end()); + + // if it's a restriction, continue; + if (std::distance(fi_begin, fi_end) == 0) + { + return boost::optional(); + } + + // check if the restriction should be ignored + const char *except = relation.get_value_by_key("except"); + if (except != nullptr) + { + if (ShouldIgnoreRestriction(except)) + { + return boost::optional(); + } + } + + bool is_only_restriction = false; + + for (auto iter = fi_begin; iter != fi_end; ++iter) + { + if (std::string("restriction") == iter->key() || + std::string("restriction::hgv") == iter->key()) + { + const std::string restriction_value(iter->value()); + + if (restriction_value.find("only_") == 0) + { + is_only_restriction = true; + } + } + } + + InputRestrictionContainer restriction_container(is_only_restriction); + + for (const auto &member : relation.members()) + { + const char *role = member.role(); + if (strcmp("from", role) != 0 && strcmp("to", role) != 0 && strcmp("via", role) != 0) + { + continue; + } + + switch (member.type()) + { + case osmium::item_type::node: + // Make sure nodes appear only in the role if a via node + if (0 == strcmp("from", role) || 0 == strcmp("to", role)) + { + continue; + } + BOOST_ASSERT(0 == strcmp("via", role)); + // set the via node id + // SimpleLogger().Write() << "via: " << member.ref(); + + restriction_container.restriction.via.node = member.ref(); + break; + + case osmium::item_type::way: + BOOST_ASSERT(0 == strcmp("from", role) || 0 == strcmp("to", role) || + 0 == strcmp("via", role)); + if (0 == strcmp("from", role)) + { + // SimpleLogger().Write() << "from: " << member.ref(); + restriction_container.restriction.from.way = member.ref(); + } + else if (0 == strcmp("to", role)) + { + // SimpleLogger().Write() << "to: " << member.ref(); + restriction_container.restriction.to.way = member.ref(); + } + else if (0 == strcmp("via", role)) + { + // not yet suppported + // restriction_container.restriction.via.way = member.ref(); + } + break; + case osmium::item_type::relation: + // not yet supported, but who knows what the future holds... + continue; + BOOST_ASSERT(false); + + break; + default: + BOOST_ASSERT(false); + } + } + + // SimpleLogger().Write() << (restriction_container.restriction.flags.is_only ? "only" : "no") + // << "-restriction " + // << "<" << restriction_container.restriction.from.node << "->" + // << restriction_container.restriction.via.node << "->" << restriction_container.restriction.to.node + // << ">"; + + return boost::optional(restriction_container); +} + +bool RestrictionParser::ShouldIgnoreRestriction(const std::string &except_tag_string) const +{ + // should this restriction be ignored? yes if there's an overlap between: + // a) the list of modes in the except tag of the restriction + // (except_tag_string), eg: except=bus;bicycle + // b) the lua profile defines a hierachy of modes, + // eg: [access, vehicle, bicycle] + + if (except_tag_string.empty()) + { + return false; + } + + // Be warned, this is quadratic work here, but we assume that + // only a few exceptions are actually defined. + std::vector exceptions; + boost::algorithm::split_regex(exceptions, except_tag_string, boost::regex("[;][ ]*")); + for (std::string ¤t_string : exceptions) + { + const auto string_iterator = + std::find(restriction_exceptions.begin(), restriction_exceptions.end(), current_string); + if (restriction_exceptions.end() != string_iterator) + { + return true; + } + } + return false; +} From d071e92a1ca13a24c74d33e33aa2b091c6615786 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Tue, 26 Aug 2014 16:35:46 +0200 Subject: [PATCH 04/80] implement restriction parsing --- Extractor/RestrictionParser.h | 63 +++++++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 Extractor/RestrictionParser.h diff --git a/Extractor/RestrictionParser.h b/Extractor/RestrictionParser.h new file mode 100644 index 000000000..433a46e85 --- /dev/null +++ b/Extractor/RestrictionParser.h @@ -0,0 +1,63 @@ +/* + +Copyright (c) 2013, Project OSRM, Dennis Luxen, others +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +*/ + +#ifndef RESTRICTION_PARSER_H_ +#define RESTRICTION_PARSER_H_ + +#include "../DataStructures/Restriction.h" + +#include + +#include +#include + + + +#include +#include + +struct lua_State; +class ScriptingEnvironment; + +class RestrictionParser +{ + public: + RestrictionParser(ScriptingEnvironment &scripting_environment); + + boost::optional TryParse(osmium::Relation& relation) const; + + void ReadUseRestrictionsSetting(); + void ReadRestrictionExceptions(); + private: + bool ShouldIgnoreRestriction(const std::string &except_tag_string) const; + + lua_State *lua_state; + std::vector restriction_exceptions; + bool use_turn_restrictions; +}; + +#endif /* RESTRICTION_PARSER_H_ */ From 2f6f883f7f5332ba72fd12db66f5d62866631f7f Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Tue, 26 Aug 2014 17:02:05 +0200 Subject: [PATCH 05/80] implement ExtractionWay and -Node --- Extractor/ExtractionNode.h | 42 ++++++++++++++++++++++++++++++++++++++ Extractor/ExtractionWay.h | 25 +++++++---------------- 2 files changed, 49 insertions(+), 18 deletions(-) create mode 100644 Extractor/ExtractionNode.h diff --git a/Extractor/ExtractionNode.h b/Extractor/ExtractionNode.h new file mode 100644 index 000000000..44b334ab8 --- /dev/null +++ b/Extractor/ExtractionNode.h @@ -0,0 +1,42 @@ +/* + +Copyright (c) 2013, Project OSRM, Dennis Luxen, others +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +*/ + +#ifndef EXTRACTION_NODE_H__ +#define EXTRACTION_NODE_H__ + +struct ExtractionNode +{ + ExtractionNode() : traffic_lights(false), barrier(false) { } + void Clear() + { + traffic_lights = barrier = false; + } + bool traffic_lights; + bool barrier; +}; + +#endif diff --git a/Extractor/ExtractionWay.h b/Extractor/ExtractionWay.h index 36c138f89..0a1d9adae 100644 --- a/Extractor/ExtractionWay.h +++ b/Extractor/ExtractionWay.h @@ -41,19 +41,13 @@ struct ExtractionWay inline void Clear() { - id = SPECIAL_NODEID; - nameID = INVALID_NAMEID; - path.clear(); - keyVals.Clear(); forward_speed = -1; backward_speed = -1; duration = -1; - access = true; roundabout = false; - isAccessRestricted = false; - ignoreInGrid = false; - forward_travel_mode = TRAVEL_MODE_DEFAULT; - backward_travel_mode = TRAVEL_MODE_DEFAULT; + is_access_restricted = false; + ignore_in_grid = false; + name.clear(); } enum Directions @@ -61,9 +55,9 @@ struct ExtractionWay oneway, bidirectional, opposite }; - + // These accessor methods exists to support the depreciated "way.direction" access - // in LUA. Since the direction attribute was removed from ExtractionWay, the + // in LUA. Since the direction attribute was removed from ExtractionWay, the // accessors translate to/from the mode attributes. inline void set_direction(const Directions m) { @@ -111,18 +105,13 @@ struct ExtractionWay inline void set_backward_mode(const TravelMode m) { backward_travel_mode = m; } inline const TravelMode get_backward_mode() const { return backward_travel_mode; } - unsigned id; - unsigned nameID; double forward_speed; double backward_speed; double duration; std::string name; - bool access; bool roundabout; - bool isAccessRestricted; - bool ignoreInGrid; - std::vector path; - HashTable keyVals; + bool is_access_restricted; + bool ignore_in_grid; TravelMode forward_travel_mode : 4; TravelMode backward_travel_mode : 4; }; From c4e785e523ada66cb44f590e4d14d403351c6252 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Tue, 26 Aug 2014 17:12:48 +0200 Subject: [PATCH 06/80] remove explicit keyword from WayIDStartAndEndEdge ctor --- Extractor/ExtractorStructs.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Extractor/ExtractorStructs.h b/Extractor/ExtractorStructs.h index a3c6f3eaf..39c4bbf2b 100644 --- a/Extractor/ExtractorStructs.h +++ b/Extractor/ExtractorStructs.h @@ -58,7 +58,7 @@ struct WayIDStartAndEndEdge { } - explicit WayIDStartAndEndEdge(unsigned w, NodeID fs, NodeID ft, NodeID ls, NodeID lt) + WayIDStartAndEndEdge(unsigned w, NodeID fs, NodeID ft, NodeID ls, NodeID lt) : wayID(w), firstStart(fs), firstTarget(ft), lastStart(ls), lastTarget(lt) { } From 8b7bf94aae885f5e3ade83534362dcc5d89eb568 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Tue, 26 Aug 2014 17:20:40 +0200 Subject: [PATCH 07/80] implement new Restriction type --- DataStructures/Restriction.h | 87 +++++++++--------------------------- 1 file changed, 21 insertions(+), 66 deletions(-) diff --git a/DataStructures/Restriction.h b/DataStructures/Restriction.h index bda0f0196..cdedc57d3 100644 --- a/DataStructures/Restriction.h +++ b/DataStructures/Restriction.h @@ -34,19 +34,25 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. struct TurnRestriction { - NodeID viaNode; - NodeID fromNode; - NodeID toNode; + union WayOrNode + { + NodeID node; + EdgeID way; + }; + WayOrNode via; + WayOrNode from; + WayOrNode to; + struct Bits { // mostly unused Bits() - : isOnly(false), unused1(false), unused2(false), unused3(false), unused4(false), + : is_only(false), uses_via_way(false), unused2(false), unused3(false), unused4(false), unused5(false), unused6(false), unused7(false) { } - bool isOnly : 1; - bool unused1 : 1; + bool is_only : 1; + bool uses_via_way : 1; bool unused2 : 1; bool unused3 : 1; bool unused4 : 1; @@ -55,72 +61,21 @@ struct TurnRestriction bool unused7 : 1; } flags; - explicit TurnRestriction(NodeID viaNode) - : viaNode(viaNode), fromNode(std::numeric_limits::max()), - toNode(std::numeric_limits::max()) + explicit TurnRestriction(NodeID node) { + via.node = node; + from.node = SPECIAL_NODEID; + to.node = SPECIAL_NODEID; } - explicit TurnRestriction(const bool isOnly = false) - : viaNode(std::numeric_limits::max()), - fromNode(std::numeric_limits::max()), - toNode(std::numeric_limits::max()) + explicit TurnRestriction(const bool is_only = false) { - flags.isOnly = isOnly; + via.node = SPECIAL_NODEID; + from.node = SPECIAL_NODEID; + to.node = SPECIAL_NODEID; + flags.is_only = is_only; } }; -struct InputRestrictionContainer -{ - EdgeID fromWay; - EdgeID toWay; - unsigned viaNode; - TurnRestriction restriction; - - InputRestrictionContainer(EdgeID fromWay, EdgeID toWay, NodeID vn, unsigned vw) - : fromWay(fromWay), toWay(toWay), viaNode(vw) - { - restriction.viaNode = vn; - } - explicit InputRestrictionContainer(bool isOnly = false) - : fromWay(std::numeric_limits::max()), - toWay(std::numeric_limits::max()), viaNode(std::numeric_limits::max()) - { - restriction.flags.isOnly = isOnly; - } - - static InputRestrictionContainer min_value() { return InputRestrictionContainer(0, 0, 0, 0); } - static InputRestrictionContainer max_value() - { - return InputRestrictionContainer(std::numeric_limits::max(), - std::numeric_limits::max(), - std::numeric_limits::max(), - std::numeric_limits::max()); - } -}; - -struct CmpRestrictionContainerByFrom -{ - using value_type = InputRestrictionContainer; - inline bool operator()(const InputRestrictionContainer &a, const InputRestrictionContainer &b) - const - { - return a.fromWay < b.fromWay; - } - inline value_type max_value() const { return InputRestrictionContainer::max_value(); } - inline value_type min_value() const { return InputRestrictionContainer::min_value(); } -}; - -struct CmpRestrictionContainerByTo -{ - using value_type = InputRestrictionContainer; - inline bool operator()(const InputRestrictionContainer &a, const InputRestrictionContainer &b) - const - { - return a.toWay < b.toWay; - } - value_type max_value() const { return InputRestrictionContainer::max_value(); } - value_type min_value() const { return InputRestrictionContainer::min_value(); } -}; #endif // RESTRICTION_H From ac9566d3d7bb2b96deeea254b86ea7a9668645af Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Tue, 26 Aug 2014 17:27:39 +0200 Subject: [PATCH 08/80] add include dir to libosmium --- CMakeLists.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/CMakeLists.txt b/CMakeLists.txt index 839f70503..518f13693 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -31,6 +31,7 @@ OPTION(WITH_TOOLS "Build OSRM tools" OFF) OPTION(BUILD_TOOLS "Build OSRM tools" OFF) include_directories(${CMAKE_SOURCE_DIR}/Include/) +include_directories(${CMAKE_SOURCE_DIR}/ThirdParty/) add_custom_command(OUTPUT ${CMAKE_SOURCE_DIR}/Util/FingerPrint.cpp FingerPrint.cpp.alwaysbuild COMMAND ${CMAKE_COMMAND} -DSOURCE_DIR=${CMAKE_SOURCE_DIR} From 05a79f5b55a4903dd081e0b49470f6c9229537c9 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Tue, 26 Aug 2014 17:28:19 +0200 Subject: [PATCH 09/80] implement loader routines for new restriction type --- Util/GraphLoader.h | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Util/GraphLoader.h b/Util/GraphLoader.h index 94cb19037..5ce600bd0 100644 --- a/Util/GraphLoader.h +++ b/Util/GraphLoader.h @@ -99,29 +99,29 @@ NodeID readBinaryOSRMGraphFromStream(std::istream &input_stream, SimpleLogger().Write() << " and " << m << " edges "; for (TurnRestriction ¤t_restriction : restriction_list) { - auto internal_id_iter = ext_to_int_id_map.find(current_restriction.fromNode); + auto internal_id_iter = ext_to_int_id_map.find(current_restriction.from.node); if (internal_id_iter == ext_to_int_id_map.end()) { SimpleLogger().Write(logDEBUG) << "Unmapped from Node of restriction"; continue; } - current_restriction.fromNode = internal_id_iter->second; + current_restriction.from.node = internal_id_iter->second; - internal_id_iter = ext_to_int_id_map.find(current_restriction.viaNode); + internal_id_iter = ext_to_int_id_map.find(current_restriction.via.node); if (internal_id_iter == ext_to_int_id_map.end()) { SimpleLogger().Write(logDEBUG) << "Unmapped via node of restriction"; continue; } - current_restriction.viaNode = internal_id_iter->second; + current_restriction.via.node = internal_id_iter->second; - internal_id_iter = ext_to_int_id_map.find(current_restriction.toNode); + internal_id_iter = ext_to_int_id_map.find(current_restriction.to.node); if (internal_id_iter == ext_to_int_id_map.end()) { SimpleLogger().Write(logDEBUG) << "Unmapped to node of restriction"; continue; } - current_restriction.toNode = internal_id_iter->second; + current_restriction.to.node = internal_id_iter->second; } edge_list.reserve(m); From 2d677a8af99b66d887cf5e3b7fd8fa1d1a098849 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Tue, 26 Aug 2014 17:30:15 +0200 Subject: [PATCH 10/80] support new restriction type in component analysis --- Algorithms/StronglyConnectedComponents.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Algorithms/StronglyConnectedComponents.h b/Algorithms/StronglyConnectedComponents.h index 4bee59109..846ed41d7 100644 --- a/Algorithms/StronglyConnectedComponents.h +++ b/Algorithms/StronglyConnectedComponents.h @@ -119,8 +119,8 @@ class TarjanSCC TIMER_START(SCC_LOAD); for (const TurnRestriction &restriction : irs) { - std::pair restriction_source = {restriction.fromNode, - restriction.viaNode}; + std::pair restriction_source = {restriction.from.node, + restriction.via.node}; unsigned index = 0; const auto restriction_iterator = m_restriction_map.find(restriction_source); if (restriction_iterator == m_restriction_map.end()) @@ -137,7 +137,7 @@ class TarjanSCC { continue; } - else if (restriction.flags.isOnly) + else if (restriction.flags.is_only) { // We are going to insert an is_only_*-restriction. There can be only one. m_restriction_bucket_list.at(index).clear(); @@ -145,7 +145,7 @@ class TarjanSCC } m_restriction_bucket_list.at(index) - .emplace_back(restriction.toNode, restriction.flags.isOnly); + .emplace_back(restriction.to.node, restriction.flags.is_only); } barrier_node_list.insert(bn.begin(), bn.end()); From 958350af823424d0aff8abfc86090ee5e04de001 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Tue, 26 Aug 2014 17:35:31 +0200 Subject: [PATCH 11/80] add InputRestrictionContainer implementation --- DataStructures/Restriction.h | 51 ++++++++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) diff --git a/DataStructures/Restriction.h b/DataStructures/Restriction.h index cdedc57d3..c1cfc119f 100644 --- a/DataStructures/Restriction.h +++ b/DataStructures/Restriction.h @@ -77,5 +77,56 @@ struct TurnRestriction } }; +struct InputRestrictionContainer +{ + // EdgeID fromWay; + // EdgeID toWay; + // NodeID via_node; + TurnRestriction restriction; + + InputRestrictionContainer(EdgeID fromWay, EdgeID toWay, EdgeID vw) + { + restriction.from.way = fromWay; + restriction.to.way = toWay; + restriction.via.way = vw; + } + explicit InputRestrictionContainer(bool is_only = false) + { + restriction.from.way = SPECIAL_EDGEID; + restriction.to.way = SPECIAL_EDGEID; + restriction.via.node = SPECIAL_NODEID; + restriction.flags.is_only = is_only; + } + + static InputRestrictionContainer min_value() { return InputRestrictionContainer(0, 0, 0); } + static InputRestrictionContainer max_value() + { + return InputRestrictionContainer(SPECIAL_EDGEID, SPECIAL_EDGEID, SPECIAL_EDGEID); + } +}; + +struct CmpRestrictionContainerByFrom +{ + typedef InputRestrictionContainer value_type; + inline bool operator()(const InputRestrictionContainer &a, + const InputRestrictionContainer &b) const + { + return a.restriction.from.way < b.restriction.from.way; + } + inline value_type max_value() const { return InputRestrictionContainer::max_value(); } + inline value_type min_value() const { return InputRestrictionContainer::min_value(); } +}; + +struct CmpRestrictionContainerByTo +{ + typedef InputRestrictionContainer value_type; + inline bool operator()(const InputRestrictionContainer &a, + const InputRestrictionContainer &b) const + { + return a.restriction.to.way < b.restriction.to.way; + } + value_type max_value() const { return InputRestrictionContainer::max_value(); } + value_type min_value() const { return InputRestrictionContainer::min_value(); } +}; #endif // RESTRICTION_H From 398e3bdf8234a7b07bf253c2ba59c95589026c8b Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Tue, 26 Aug 2014 17:39:44 +0200 Subject: [PATCH 12/80] implement new restriction type interface in PrepareData --- Extractor/ExtractionContainers.cpp | 38 +++++++++++++++--------------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/Extractor/ExtractionContainers.cpp b/Extractor/ExtractionContainers.cpp index fda062e93..3b39e3476 100644 --- a/Extractor/ExtractionContainers.cpp +++ b/Extractor/ExtractionContainers.cpp @@ -111,39 +111,39 @@ void ExtractionContainers::PrepareData(const std::string &output_file_name, while (way_start_and_end_iterator != way_start_end_id_list.end() && restrictions_iterator != restrictions_list.end()) { - if (way_start_and_end_iterator->wayID < restrictions_iterator->fromWay) + if (way_start_and_end_iterator->wayID < restrictions_iterator->restriction.from.way) { ++way_start_and_end_iterator; continue; } - if (way_start_and_end_iterator->wayID > restrictions_iterator->fromWay) + if (way_start_and_end_iterator->wayID > restrictions_iterator->restriction.from.way) { ++restrictions_iterator; continue; } - BOOST_ASSERT(way_start_and_end_iterator->wayID == restrictions_iterator->fromWay); - const NodeID via_node_id = restrictions_iterator->restriction.viaNode; + BOOST_ASSERT(way_start_and_end_iterator->wayID == restrictions_iterator->restriction.from.way); + const NodeID via_node_id = restrictions_iterator->restriction.via.node; if (way_start_and_end_iterator->firstStart == via_node_id) { - restrictions_iterator->restriction.fromNode = + restrictions_iterator->restriction.from.node = way_start_and_end_iterator->firstTarget; } else if (way_start_and_end_iterator->firstTarget == via_node_id) { - restrictions_iterator->restriction.fromNode = + restrictions_iterator->restriction.from.node = way_start_and_end_iterator->firstStart; } else if (way_start_and_end_iterator->lastStart == via_node_id) { - restrictions_iterator->restriction.fromNode = + restrictions_iterator->restriction.from.node = way_start_and_end_iterator->lastTarget; } else if (way_start_and_end_iterator->lastTarget == via_node_id) { - restrictions_iterator->restriction.fromNode = way_start_and_end_iterator->lastStart; + restrictions_iterator->restriction.from.node = way_start_and_end_iterator->lastStart; } ++restrictions_iterator; } @@ -168,36 +168,36 @@ void ExtractionContainers::PrepareData(const std::string &output_file_name, while (way_start_and_end_iterator != way_start_end_id_list.end() && restrictions_iterator != restrictions_list.end()) { - if (way_start_and_end_iterator->wayID < restrictions_iterator->toWay) + if (way_start_and_end_iterator->wayID < restrictions_iterator->restriction.to.way) { ++way_start_and_end_iterator; continue; } - if (way_start_and_end_iterator->wayID > restrictions_iterator->toWay) + if (way_start_and_end_iterator->wayID > restrictions_iterator->restriction.to.way) { ++restrictions_iterator; continue; } - NodeID via_node_id = restrictions_iterator->restriction.viaNode; + NodeID via_node_id = restrictions_iterator->restriction.via.node; if (way_start_and_end_iterator->lastStart == via_node_id) { - restrictions_iterator->restriction.toNode = way_start_and_end_iterator->lastTarget; + restrictions_iterator->restriction.to.node = way_start_and_end_iterator->lastTarget; } else if (way_start_and_end_iterator->lastTarget == via_node_id) { - restrictions_iterator->restriction.toNode = way_start_and_end_iterator->lastStart; + restrictions_iterator->restriction.to.node = way_start_and_end_iterator->lastStart; } else if (way_start_and_end_iterator->firstStart == via_node_id) { - restrictions_iterator->restriction.toNode = way_start_and_end_iterator->firstTarget; + restrictions_iterator->restriction.to.node = way_start_and_end_iterator->firstTarget; } else if (way_start_and_end_iterator->firstTarget == via_node_id) { - restrictions_iterator->restriction.toNode = way_start_and_end_iterator->firstStart; + restrictions_iterator->restriction.to.node = way_start_and_end_iterator->firstStart; } - if (std::numeric_limits::max() != restrictions_iterator->restriction.fromNode && - std::numeric_limits::max() != restrictions_iterator->restriction.toNode) + if (std::numeric_limits::max() != restrictions_iterator->restriction.from.node && + std::numeric_limits::max() != restrictions_iterator->restriction.to.node) { ++number_of_useable_restrictions; } @@ -215,8 +215,8 @@ void ExtractionContainers::PrepareData(const std::string &output_file_name, for(const auto & restriction_container : restrictions_list) { - if (std::numeric_limits::max() != restriction_container.restriction.fromNode && - std::numeric_limits::max() != restriction_container.restriction.toNode) + if (std::numeric_limits::max() != restriction_container.restriction.from.node && + std::numeric_limits::max() != restriction_container.restriction.to.node) { restrictions_out_stream.write((char *)&(restriction_container.restriction), sizeof(TurnRestriction)); From 004c237085276bc9a05537fcb124a66c9df0d2ff Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Tue, 26 Aug 2014 17:50:09 +0200 Subject: [PATCH 13/80] implement restriction type interface in RestrictionMap --- DataStructures/RestrictionMap.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/DataStructures/RestrictionMap.cpp b/DataStructures/RestrictionMap.cpp index f2c56e0cf..7f61ead01 100644 --- a/DataStructures/RestrictionMap.cpp +++ b/DataStructures/RestrictionMap.cpp @@ -41,10 +41,10 @@ RestrictionMap::RestrictionMap(const std::shared_ptr &gra // a pair of starting edge and a list of all end nodes for (auto &restriction : restriction_list) { - m_restriction_start_nodes.insert(restriction.fromNode); - m_no_turn_via_node_set.insert(restriction.viaNode); + m_restriction_start_nodes.insert(restriction.from.node); + m_no_turn_via_node_set.insert(restriction.via.node); - RestrictionSource restriction_source = {restriction.fromNode, restriction.viaNode}; + RestrictionSource restriction_source = {restriction.from.node, restriction.via.node}; unsigned index; auto restriction_iter = m_restriction_map.find(restriction_source); @@ -62,7 +62,7 @@ RestrictionMap::RestrictionMap(const std::shared_ptr &gra { continue; } - else if (restriction.flags.isOnly) + else if (restriction.flags.is_only) { // We are going to insert an is_only_*-restriction. There can be only one. m_count -= m_restriction_bucket_list.at(index).size(); @@ -71,7 +71,7 @@ RestrictionMap::RestrictionMap(const std::shared_ptr &gra } ++m_count; m_restriction_bucket_list.at(index) - .emplace_back(restriction.toNode, restriction.flags.isOnly); + .emplace_back(restriction.to.node, restriction.flags.is_only); } } From b6e469abd12660c839da229d13476ed2528edbfb Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Tue, 26 Aug 2014 17:50:34 +0200 Subject: [PATCH 14/80] implement parsing thru libosmium --- Extractor/Extractor.cpp | 120 +++++++++++++++++++------ Extractor/Extractor.h | 3 +- Extractor/ExtractorCallbacks.cpp | 145 +++++++++++++++++++------------ Extractor/ExtractorCallbacks.h | 15 ++-- 4 files changed, 194 insertions(+), 89 deletions(-) diff --git a/Extractor/Extractor.cpp b/Extractor/Extractor.cpp index 084976851..6a467bab7 100644 --- a/Extractor/Extractor.cpp +++ b/Extractor/Extractor.cpp @@ -27,23 +27,29 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "Extractor.h" -#include "ExtractorCallbacks.h" #include "ExtractionContainers.h" -#include "PBFParser.h" +#include "ExtractionNode.h" +#include "ExtractionWay.h" +#include "ExtractorCallbacks.h" +#include "RestrictionParser.h" #include "ScriptingEnvironment.h" -#include "XMLParser.h" #include "../Util/GitDescription.h" #include "../Util/IniFileUtil.h" #include "../Util/OSRMException.h" #include "../Util/simple_logger.hpp" #include "../Util/TimingUtil.h" +#include "../Util/make_unique.hpp" #include "../typedefs.h" #include +#include + #include +#include + #include #include @@ -56,7 +62,14 @@ Extractor::Extractor() : requested_num_threads(0), file_has_pbf_format(false) { } -Extractor::~Extractor() {} +int lua_error_callback(lua_State *L) // This is so I can use my own function as an +// exception handler, pcall_log() +{ + luabind::object error_msg(luabind::from_stack(L, -1)); + std::ostringstream error_stream; + error_stream << error_msg; + throw OSRMException("ERROR occured in profile script:\n" + error_stream.str()); +} bool Extractor::ParseArguments(int argc, char *argv[]) { @@ -176,17 +189,20 @@ void Extractor::GenerateOutputFilesNames() { output_file_name.append(".osrm"); restriction_file_name.append(".osrm.restrictions"); + timestamp_file_name.append(".osrm.timestamp"); } else { output_file_name.replace(pos, 5, ".osrm"); restriction_file_name.replace(pos, 5, ".osrm.restrictions"); + timestamp_file_name.replace(pos, 5, ".osrm.timestamp"); } } else { output_file_name.replace(pos, 8, ".osrm"); restriction_file_name.replace(pos, 8, ".osrm.restrictions"); + timestamp_file_name.replace(pos, 8, ".osrm.timestamp"); } } @@ -244,36 +260,88 @@ int Extractor::Run(int argc, char *argv[]) ExtractionContainers extraction_containers; string_map[""] = 0; - auto extractor_callbacks = new ExtractorCallbacks(extraction_containers, string_map); - BaseParser *parser; - if (file_has_pbf_format) - { - parser = new PBFParser(input_path.string().c_str(), - extractor_callbacks, - scripting_environment, - requested_num_threads); - } - else - { - parser = new XMLParser(input_path.string().c_str(), - extractor_callbacks, - scripting_environment); - } + auto extractor_callbacks = osrm::make_unique(extraction_containers, string_map); - if (!parser->ReadHeader()) - { - throw OSRMException("Parser not initialized!"); - } + osmium::io::File infile(input_path.string()); + osmium::io::Reader reader(infile); + osmium::io::Header header = reader.header(); + + unsigned number_of_nodes = 0; + unsigned number_of_ways = 0; + unsigned number_of_relations = 0; + unsigned number_of_others = 0; SimpleLogger().Write() << "Parsing in progress.."; TIMER_START(parsing); - parser->Parse(); - delete parser; - delete extractor_callbacks; + std::string generator = header.get("generator"); + if (generator.empty()) + { + generator = "unknown tool"; + } + SimpleLogger().Write() << "input file generated by " << generator; + // TODO: write timestamp if non-empty + std::string timestamp = header.get("osmosis_replication_timestamp"); + if (timestamp.empty()) + { + timestamp = "n/a"; + } + SimpleLogger().Write() << "timestamp: " << timestamp; + + boost::filesystem::ofstream timestamp_out(timestamp_file_name); + timestamp_out.write(timestamp.c_str(), timestamp.length()); + timestamp_out.close(); + + lua_State *lua_state = scripting_environment.getLuaState(); + luabind::set_pcall_callback(&lua_error_callback); + + RestrictionParser restriction_parser(scripting_environment); + + ExtractionNode result_node; + ExtractionWay result_way; + + while (osmium::memory::Buffer buffer = reader.read()) { + for (osmium::OSMEntity &entity : buffer) + { + switch (entity.type()) + { + case osmium::item_type::node: + ++number_of_nodes; + result_node.Clear(); + luabind::call_function( + lua_state, + "node_function", + boost::cref(static_cast(entity)), + boost::ref(result_node)); + extractor_callbacks->ProcessNode(static_cast(entity), + result_node); + break; + case osmium::item_type::way: + ++number_of_ways; + result_way.Clear(); + luabind::call_function( + lua_state, + "way_function", + boost::cref(static_cast(entity)), + boost::ref(result_way)); + extractor_callbacks->ProcessWay(static_cast(entity), + result_way); + break; + case osmium::item_type::relation: + ++number_of_relations; + extractor_callbacks->ProcessRestriction( + restriction_parser.TryParse(static_cast(entity))); + break; + default: + ++number_of_others; + break; + } + } + } TIMER_STOP(parsing); SimpleLogger().Write() << "Parsing finished after " << TIMER_SEC(parsing) << " seconds"; + extractor_callbacks.reset(); if (extraction_containers.all_edges_list.empty()) { diff --git a/Extractor/Extractor.h b/Extractor/Extractor.h index 70c943a06..355c5be90 100644 --- a/Extractor/Extractor.h +++ b/Extractor/Extractor.h @@ -18,6 +18,7 @@ class Extractor std::string output_file_name; std::string restriction_file_name; + std::string timestamp_file_name; bool file_has_pbf_format; /** \brief Parses "extractor's" command line arguments */ @@ -29,7 +30,7 @@ class Extractor public: explicit Extractor(); Extractor(const Extractor &) = delete; - virtual ~Extractor(); + virtual ~Extractor() = default; int Run(int argc, char *argv[]); }; diff --git a/Extractor/ExtractorCallbacks.cpp b/Extractor/ExtractorCallbacks.cpp index 16bd77aa6..561fe9e36 100644 --- a/Extractor/ExtractorCallbacks.cpp +++ b/Extractor/ExtractorCallbacks.cpp @@ -27,10 +27,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "ExtractorCallbacks.h" #include "ExtractionContainers.h" +#include "ExtractionNode.h" #include "ExtractionWay.h" #include "../DataStructures/Restriction.h" #include "../DataStructures/ImportNode.h" +#include "../Util/container.hpp" #include "../Util/simple_logger.hpp" #include @@ -46,22 +48,28 @@ ExtractorCallbacks::ExtractorCallbacks(ExtractionContainers &extraction_containe } /** warning: caller needs to take care of synchronization! */ -void ExtractorCallbacks::ProcessNode(const ExternalMemoryNode &n) +void ExtractorCallbacks::ProcessNode(const osmium::Node &osm_input_node, const ExtractionNode &result_node) { - if (n.lat <= 85 * COORDINATE_PRECISION && n.lat >= -85 * COORDINATE_PRECISION) + //TODO: sort out datatype issues + ExternalMemoryNode node; + node.bollard = result_node.barrier; + node.trafficLight = result_node.traffic_lights; + node.lat = osm_input_node.location().lat() * COORDINATE_PRECISION; + node.lon = osm_input_node.location().lon() * COORDINATE_PRECISION; + node.node_id = osm_input_node.id(); + external_memory.all_nodes_list.push_back(node); +} + +void ExtractorCallbacks::ProcessRestriction(const boost::optional &restriction) +{ + if (!restriction.is_initialized()) { - external_memory.all_nodes_list.push_back(n); + return; } + external_memory.restrictions_list.push_back(restriction.get()); } - -bool ExtractorCallbacks::ProcessRestriction(const InputRestrictionContainer &restriction) -{ - external_memory.restrictions_list.push_back(restriction); - return true; -} - /** warning: caller needs to take care of synchronization! */ -void ExtractorCallbacks::ProcessWay(ExtractionWay &parsed_way) +void ExtractorCallbacks::ProcessWay(const osmium::Way ¤t_way, ExtractionWay &parsed_way) { if (((0 >= parsed_way.forward_speed) || (TRAVEL_MODE_INACCESSIBLE == parsed_way.forward_travel_mode)) && @@ -72,15 +80,15 @@ void ExtractorCallbacks::ProcessWay(ExtractionWay &parsed_way) return; } - if (parsed_way.path.size() <= 1) + if (current_way.nodes().size() <= 1) { // safe-guard against broken data return; } - if (std::numeric_limits::max() == parsed_way.id) + if (std::numeric_limits::max() == current_way.id()) { - SimpleLogger().Write(logDEBUG) << "found bogus way with id: " << parsed_way.id - << " of size " << parsed_way.path.size(); + SimpleLogger().Write(logDEBUG) << "found bogus way with id: " << current_way.id() + << " of size " << current_way.nodes().size(); return; } @@ -88,34 +96,27 @@ void ExtractorCallbacks::ProcessWay(ExtractionWay &parsed_way) { // TODO: iterate all way segments and set duration corresponding to the length of each // segment - parsed_way.forward_speed = parsed_way.duration / (parsed_way.path.size() - 1); - parsed_way.backward_speed = parsed_way.duration / (parsed_way.path.size() - 1); + parsed_way.forward_speed = parsed_way.duration / (current_way.nodes().size() - 1); + parsed_way.backward_speed = parsed_way.duration / (current_way.nodes().size() - 1); } if (std::numeric_limits::epsilon() >= std::abs(-1. - parsed_way.forward_speed)) { - SimpleLogger().Write(logDEBUG) << "found way with bogus speed, id: " << parsed_way.id; + SimpleLogger().Write(logDEBUG) << "found way with bogus speed, id: " << current_way.id(); return; } // Get the unique identifier for the street name const auto &string_map_iterator = string_map.find(parsed_way.name); + unsigned name_id = external_memory.name_list.size(); if (string_map.end() == string_map_iterator) { - parsed_way.nameID = external_memory.name_list.size(); external_memory.name_list.push_back(parsed_way.name); - string_map.insert(std::make_pair(parsed_way.name, parsed_way.nameID)); + string_map.insert(std::make_pair(parsed_way.name, name_id)); } else { - parsed_way.nameID = string_map_iterator->second; - } - - if (TRAVEL_MODE_INACCESSIBLE == parsed_way.forward_travel_mode) - { - std::reverse(parsed_way.path.begin(), parsed_way.path.end()); - parsed_way.forward_travel_mode = parsed_way.backward_travel_mode; - parsed_way.backward_travel_mode = TRAVEL_MODE_INACCESSIBLE; + name_id = string_map_iterator->second; } const bool split_edge = @@ -124,59 +125,89 @@ void ExtractorCallbacks::ProcessWay(ExtractionWay &parsed_way) ((parsed_way.forward_speed != parsed_way.backward_speed) || (parsed_way.forward_travel_mode != parsed_way.backward_travel_mode)); - BOOST_ASSERT(parsed_way.forward_travel_mode>0); - for (unsigned n = 0; n < (parsed_way.path.size() - 1); ++n) - { - external_memory.all_edges_list.push_back(InternalExtractorEdge( - parsed_way.path[n], - parsed_way.path[n + 1], + auto pair_wise_segment_split = [&](const osmium::NodeRef &first_node, + const osmium::NodeRef &last_node) { + // SimpleLogger().Write() << "adding edge (" << first_node.ref() << "," << + // last_node.ref() << "), speed: " << parsed_way.speed; + external_memory.all_edges_list.push_back( + InternalExtractorEdge(first_node.ref(), + last_node.ref(), ((split_edge || TRAVEL_MODE_INACCESSIBLE == parsed_way.backward_travel_mode) ? ExtractionWay::oneway : ExtractionWay::bidirectional), parsed_way.forward_speed, - parsed_way.nameID, + name_id, parsed_way.roundabout, - parsed_way.ignoreInGrid, + parsed_way.ignore_in_grid, (0 < parsed_way.duration), - parsed_way.isAccessRestricted, + parsed_way.is_access_restricted, parsed_way.forward_travel_mode, split_edge)); - external_memory.used_node_id_list.push_back(parsed_way.path[n]); + external_memory.used_node_id_list.push_back(first_node.ref()); + }; + + const bool is_opposite_way = TRAVEL_MODE_INACCESSIBLE == parsed_way.forward_travel_mode; + if (is_opposite_way) + { + parsed_way.forward_travel_mode = parsed_way.backward_travel_mode; + parsed_way.backward_travel_mode = TRAVEL_MODE_INACCESSIBLE; + osrm::for_each_pair(current_way.nodes().crbegin(), current_way.nodes().crend(), pair_wise_segment_split); + external_memory.used_node_id_list.push_back(current_way.nodes().front().ref()); + } + else + { + osrm::for_each_pair(current_way.nodes().cbegin(), current_way.nodes().cend(), pair_wise_segment_split); + external_memory.used_node_id_list.push_back(current_way.nodes().back().ref()); } - external_memory.used_node_id_list.push_back(parsed_way.path.back()); // The following information is needed to identify start and end segments of restrictions + // The following information is needed to identify start and end segments of restrictions external_memory.way_start_end_id_list.push_back( - WayIDStartAndEndEdge(parsed_way.id, - parsed_way.path[0], - parsed_way.path[1], - parsed_way.path[parsed_way.path.size() - 2], - parsed_way.path.back())); + {(EdgeID)current_way.id(), + (NodeID)current_way.nodes()[0].ref(), + (NodeID)current_way.nodes()[1].ref(), + (NodeID)current_way.nodes()[current_way.nodes().size() - 2].ref(), + (NodeID)current_way.nodes().back().ref()}); if (split_edge) { // Only true if the way should be split BOOST_ASSERT(parsed_way.backward_travel_mode>0); - std::reverse(parsed_way.path.begin(), parsed_way.path.end()); - - for (std::vector::size_type n = 0; n < parsed_way.path.size() - 1; ++n) + auto pair_wise_segment_split_2 = [&](const osmium::NodeRef &first_node, + const osmium::NodeRef &last_node) { + // SimpleLogger().Write() << "adding edge (" << last_node.ref() << "," << + // first_node.ref() << "), speed: " << parsed_way.backward_speed; external_memory.all_edges_list.push_back( - InternalExtractorEdge(parsed_way.path[n], - parsed_way.path[n + 1], + InternalExtractorEdge(last_node.ref(), + first_node.ref(), ExtractionWay::oneway, parsed_way.backward_speed, - parsed_way.nameID, + name_id, parsed_way.roundabout, - parsed_way.ignoreInGrid, + parsed_way.ignore_in_grid, (0 < parsed_way.duration), - parsed_way.isAccessRestricted, + parsed_way.is_access_restricted, parsed_way.backward_travel_mode, split_edge)); + }; + + if (is_opposite_way) + { + // SimpleLogger().Write() << "opposite2"; + osrm::for_each_pair(current_way.nodes().crbegin(), current_way.nodes().crend(), pair_wise_segment_split_2); + external_memory.used_node_id_list.push_back(current_way.nodes().front().ref()); } + else + { + osrm::for_each_pair(current_way.nodes().cbegin(), current_way.nodes().cend(), pair_wise_segment_split_2); + external_memory.used_node_id_list.push_back(current_way.nodes().back().ref()); + } + + external_memory.way_start_end_id_list.push_back( - WayIDStartAndEndEdge(parsed_way.id, - parsed_way.path[0], - parsed_way.path[1], - parsed_way.path[parsed_way.path.size() - 2], - parsed_way.path.back())); + {(EdgeID)current_way.id(), + (NodeID)current_way.nodes()[1].ref(), + (NodeID)current_way.nodes()[0].ref(), + (NodeID)current_way.nodes().back().ref(), + (NodeID)current_way.nodes()[current_way.nodes().size() - 2].ref()}); } } diff --git a/Extractor/ExtractorCallbacks.h b/Extractor/ExtractorCallbacks.h index fcdb272da..692a942b9 100644 --- a/Extractor/ExtractorCallbacks.h +++ b/Extractor/ExtractorCallbacks.h @@ -28,15 +28,20 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef EXTRACTOR_CALLBACKS_H #define EXTRACTOR_CALLBACKS_H +#include "ExtractionWay.h" #include "../typedefs.h" -#include +#include + +#include + #include +#include struct ExternalMemoryNode; class ExtractionContainers; -struct ExtractionWay; struct InputRestrictionContainer; +struct ExtractionNode; class ExtractorCallbacks { @@ -51,13 +56,13 @@ class ExtractorCallbacks std::unordered_map &string_map); // warning: caller needs to take care of synchronization! - void ProcessNode(const ExternalMemoryNode &node); + void ProcessNode(const osmium::Node ¤t_node, const ExtractionNode &result_node); // warning: caller needs to take care of synchronization! - bool ProcessRestriction(const InputRestrictionContainer &restriction); + void ProcessRestriction(const boost::optional &restriction); // warning: caller needs to take care of synchronization! - void ProcessWay(ExtractionWay &way); + void ProcessWay(const osmium::Way ¤t_way, ExtractionWay &result_way); }; #endif /* EXTRACTOR_CALLBACKS_H */ From 2a8644b72c0cda91c05ba670e3ded9ba172e3359 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Tue, 26 Aug 2014 17:51:34 +0200 Subject: [PATCH 15/80] expose libosmium types to LUA --- Extractor/ScriptingEnvironment.cpp | 56 +++++++++++++++++------------- 1 file changed, 32 insertions(+), 24 deletions(-) diff --git a/Extractor/ScriptingEnvironment.cpp b/Extractor/ScriptingEnvironment.cpp index a989ac122..db845217a 100644 --- a/Extractor/ScriptingEnvironment.cpp +++ b/Extractor/ScriptingEnvironment.cpp @@ -28,6 +28,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "ScriptingEnvironment.h" #include "ExtractionHelperFunctions.h" +#include "ExtractionNode.h" #include "ExtractionWay.h" #include "../DataStructures/ImportNode.h" #include "../Util/LuaUtil.h" @@ -35,6 +36,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "../Util/simple_logger.hpp" #include "../typedefs.h" +#include + +#include + #include ScriptingEnvironment::ScriptingEnvironment() {} @@ -46,6 +51,12 @@ ScriptingEnvironment::ScriptingEnvironment(const char *file_name) void ScriptingEnvironment::initLuaState(lua_State* lua_state) { + using namespace osmium; + + typedef double (osmium::Location::* location_member_ptr_type)() const; + + + luabind::open(lua_state); // open utility libraries string library; luaL_openlibs(lua_state); @@ -58,33 +69,30 @@ void ScriptingEnvironment::initLuaState(lua_State* lua_state) luabind::def("durationIsValid", durationIsValid), luabind::def("parseDuration", parseDuration), - luabind::class_>("keyVals") - .def("Add", &HashTable::Add) - .def("Find", &HashTable::Find) - .def("Holds", &HashTable::Holds), + luabind::class_>("vector") + .def("Add", static_cast::*)(const std::string &)>(&std::vector::push_back)), - luabind::class_("Node") - // .def(luabind::constructor<>()) - .def_readwrite("lat", &ImportNode::lat) - .def_readwrite("lon", &ImportNode::lon) - .def_readonly("id", &ImportNode::node_id) - .def_readwrite("bollard", &ImportNode::bollard) - .def_readwrite("traffic_light", &ImportNode::trafficLight) - .def_readwrite("tags", &ImportNode::keyVals), + luabind::class_("Location") + .def("lat", &osmium::Location::lat) + .def("lon", &osmium::Location::lon), - luabind::class_("Way") + luabind::class_("Node") + // .def("tags", &osmium::Node::tags) + .def("get_value_by_key", &osmium::Node::get_value_by_key), + + luabind::class_("ResultNode") + .def_readwrite("traffic_lights", &ExtractionNode::traffic_lights) + .def_readwrite("barrier", &ExtractionNode::barrier), + + luabind::class_("ResultWay") // .def(luabind::constructor<>()) - .def_readonly("id", &ExtractionWay::id) - .def_readwrite("name", &ExtractionWay::name) - .def_readwrite("forward_speed", &ExtractionWay::forward_speed) + .def_readwrite("speed", &ExtractionWay::forward_speed) .def_readwrite("backward_speed", &ExtractionWay::backward_speed) - .def_readwrite("duration", &ExtractionWay::duration) - .def_readwrite("access", &ExtractionWay::access) + .def_readwrite("name", &ExtractionWay::name) .def_readwrite("roundabout", &ExtractionWay::roundabout) - .def_readwrite("is_access_restricted", &ExtractionWay::isAccessRestricted) - .def_readwrite("ignore_in_grid", &ExtractionWay::ignoreInGrid) - .def_readwrite("tags", &ExtractionWay::keyVals) - .property("direction", &ExtractionWay::get_direction, &ExtractionWay::set_direction) + .def_readwrite("is_access_restricted", &ExtractionWay::is_access_restricted) + .def_readwrite("ignore_in_index", &ExtractionWay::ignore_in_grid) + .def_readwrite("duration", &ExtractionWay::duration) .property("forward_mode", &ExtractionWay::get_forward_mode, &ExtractionWay::set_forward_mode) .property("backward_mode", &ExtractionWay::get_backward_mode, &ExtractionWay::set_backward_mode) .enum_("constants")[ @@ -93,8 +101,8 @@ void ScriptingEnvironment::initLuaState(lua_State* lua_state) luabind::value("bidirectional", 2), luabind::value("opposite", 3) ], - luabind::class_>("vector") - .def("Add", static_cast::*)(const std::string &)>(&std::vector::push_back)) + luabind::class_("Way") + .def("get_value_by_key", &osmium::Way::get_value_by_key) ]; if (0 != luaL_dofile(lua_state, file_name.c_str())) From 60c9701c3fde57ca4d082cad3f531651f14fce1c Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Tue, 26 Aug 2014 17:58:39 +0200 Subject: [PATCH 16/80] reduce white space noise --- Extractor/ScriptingEnvironment.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/Extractor/ScriptingEnvironment.cpp b/Extractor/ScriptingEnvironment.cpp index db845217a..aba05a76e 100644 --- a/Extractor/ScriptingEnvironment.cpp +++ b/Extractor/ScriptingEnvironment.cpp @@ -55,8 +55,6 @@ void ScriptingEnvironment::initLuaState(lua_State* lua_state) typedef double (osmium::Location::* location_member_ptr_type)() const; - - luabind::open(lua_state); // open utility libraries string library; luaL_openlibs(lua_state); From 6d9598cd4c996a675358a4481c649ce9ff4b1012 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Tue, 26 Aug 2014 17:59:09 +0200 Subject: [PATCH 17/80] link against expat not libxml2, good riddance --- CMakeLists.txt | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 518f13693..b38347a7f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -239,9 +239,9 @@ else() endif() include_directories(${LUA_INCLUDE_DIR}) -find_package(LibXml2 REQUIRED) -include_directories(${LIBXML2_INCLUDE_DIR}) -target_link_libraries(osrm-extract ${LIBXML2_LIBRARIES}) +find_package(EXPAT REQUIRED) +include_directories(${EXPAT_INCLUDE_DIRS}) +target_link_libraries(osrm-extract ${EXPAT_LIBRARIES}) find_package( STXXL REQUIRED ) include_directories(${STXXL_INCLUDE_DIR}) From b7ea1dfcd06ae50345833fcf727567b771abba9a Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Tue, 26 Aug 2014 18:08:33 +0200 Subject: [PATCH 18/80] fix generation of file names --- Extractor/Extractor.cpp | 31 +++++++++++++++++-------------- 1 file changed, 17 insertions(+), 14 deletions(-) diff --git a/Extractor/Extractor.cpp b/Extractor/Extractor.cpp index 6a467bab7..f7ac4a22f 100644 --- a/Extractor/Extractor.cpp +++ b/Extractor/Extractor.cpp @@ -161,6 +161,7 @@ void Extractor::GenerateOutputFilesNames() { output_file_name = input_path.string(); restriction_file_name = input_path.string(); + timestamp_file_name = input_path.string(); std::string::size_type pos = output_file_name.find(".osm.bz2"); if (pos == std::string::npos) { @@ -309,24 +310,24 @@ int Extractor::Run(int argc, char *argv[]) case osmium::item_type::node: ++number_of_nodes; result_node.Clear(); - luabind::call_function( - lua_state, - "node_function", - boost::cref(static_cast(entity)), - boost::ref(result_node)); - extractor_callbacks->ProcessNode(static_cast(entity), - result_node); + // luabind::call_function( + // lua_state, + // "node_function", + // boost::cref(static_cast(entity)), + // boost::ref(result_node)); + // extractor_callbacks->ProcessNode(static_cast(entity), + // result_node); break; case osmium::item_type::way: ++number_of_ways; result_way.Clear(); - luabind::call_function( - lua_state, - "way_function", - boost::cref(static_cast(entity)), - boost::ref(result_way)); - extractor_callbacks->ProcessWay(static_cast(entity), - result_way); + // luabind::call_function( + // lua_state, + // "way_function", + // boost::cref(static_cast(entity)), + // boost::ref(result_way)); + // extractor_callbacks->ProcessWay(static_cast(entity), + // result_way); break; case osmium::item_type::relation: ++number_of_relations; @@ -341,6 +342,8 @@ int Extractor::Run(int argc, char *argv[]) } TIMER_STOP(parsing); SimpleLogger().Write() << "Parsing finished after " << TIMER_SEC(parsing) << " seconds"; + SimpleLogger().Write() << "Raw input contains " << number_of_nodes << " nodes, " << number_of_ways << " ways, and " << number_of_relations << " relations"; + extractor_callbacks.reset(); if (extraction_containers.all_edges_list.empty()) From 06ddceeac0d8c90a2f9b4e32eb164f9f05342d19 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Wed, 27 Aug 2014 16:22:18 +0200 Subject: [PATCH 19/80] reset travel modes on ExtractionWay::clear() --- Extractor/ExtractionWay.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Extractor/ExtractionWay.h b/Extractor/ExtractionWay.h index 0a1d9adae..439dbd9b0 100644 --- a/Extractor/ExtractionWay.h +++ b/Extractor/ExtractionWay.h @@ -48,6 +48,8 @@ struct ExtractionWay is_access_restricted = false; ignore_in_grid = false; name.clear(); + forward_travel_mode = TRAVEL_MODE_DEFAULT; + backward_travel_mode = TRAVEL_MODE_DEFAULT; } enum Directions From 80046b646bef7d6d28d593d4fc7891ce8f015754 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Wed, 27 Aug 2014 16:23:30 +0200 Subject: [PATCH 20/80] actually parse the data that flowing thru osmium --- Extractor/Extractor.cpp | 31 ++++++++++++++++--------------- 1 file changed, 16 insertions(+), 15 deletions(-) diff --git a/Extractor/Extractor.cpp b/Extractor/Extractor.cpp index f7ac4a22f..a8423e5a6 100644 --- a/Extractor/Extractor.cpp +++ b/Extractor/Extractor.cpp @@ -302,7 +302,8 @@ int Extractor::Run(int argc, char *argv[]) ExtractionNode result_node; ExtractionWay result_way; - while (osmium::memory::Buffer buffer = reader.read()) { + while (osmium::memory::Buffer buffer = reader.read()) + { for (osmium::OSMEntity &entity : buffer) { switch (entity.type()) @@ -310,24 +311,24 @@ int Extractor::Run(int argc, char *argv[]) case osmium::item_type::node: ++number_of_nodes; result_node.Clear(); - // luabind::call_function( - // lua_state, - // "node_function", - // boost::cref(static_cast(entity)), - // boost::ref(result_node)); - // extractor_callbacks->ProcessNode(static_cast(entity), - // result_node); + luabind::call_function( + lua_state, + "node_function", + boost::cref(static_cast(entity)), + boost::ref(result_node)); + extractor_callbacks->ProcessNode(static_cast(entity), + result_node); break; case osmium::item_type::way: ++number_of_ways; result_way.Clear(); - // luabind::call_function( - // lua_state, - // "way_function", - // boost::cref(static_cast(entity)), - // boost::ref(result_way)); - // extractor_callbacks->ProcessWay(static_cast(entity), - // result_way); + luabind::call_function( + lua_state, + "way_function", + boost::cref(static_cast(entity)), + boost::ref(result_way)); + extractor_callbacks->ProcessWay(static_cast(entity), + result_way); break; case osmium::item_type::relation: ++number_of_relations; From dce665f14e5d772cd0bfa087199b08c09714d2fc Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Wed, 27 Aug 2014 16:24:40 +0200 Subject: [PATCH 21/80] reformat ExtractorCallbacks --- Extractor/ExtractorCallbacks.cpp | 104 +++++++++++++++++-------------- 1 file changed, 57 insertions(+), 47 deletions(-) diff --git a/Extractor/ExtractorCallbacks.cpp b/Extractor/ExtractorCallbacks.cpp index 561fe9e36..dd57250c2 100644 --- a/Extractor/ExtractorCallbacks.cpp +++ b/Extractor/ExtractorCallbacks.cpp @@ -48,9 +48,10 @@ ExtractorCallbacks::ExtractorCallbacks(ExtractionContainers &extraction_containe } /** warning: caller needs to take care of synchronization! */ -void ExtractorCallbacks::ProcessNode(const osmium::Node &osm_input_node, const ExtractionNode &result_node) +void ExtractorCallbacks::ProcessNode(const osmium::Node &osm_input_node, + const ExtractionNode &result_node) { - //TODO: sort out datatype issues + // TODO: use in-place c'tion ExternalMemoryNode node; node.bollard = result_node.barrier; node.trafficLight = result_node.traffic_lights; @@ -60,35 +61,36 @@ void ExtractorCallbacks::ProcessNode(const osmium::Node &osm_input_node, const E external_memory.all_nodes_list.push_back(node); } -void ExtractorCallbacks::ProcessRestriction(const boost::optional &restriction) +void ExtractorCallbacks::ProcessRestriction( + const boost::optional &restriction) { if (!restriction.is_initialized()) { - return; + return; } external_memory.restrictions_list.push_back(restriction.get()); } /** warning: caller needs to take care of synchronization! */ -void ExtractorCallbacks::ProcessWay(const osmium::Way ¤t_way, ExtractionWay &parsed_way) +void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, ExtractionWay &parsed_way) { if (((0 >= parsed_way.forward_speed) || - (TRAVEL_MODE_INACCESSIBLE == parsed_way.forward_travel_mode)) && + (TRAVEL_MODE_INACCESSIBLE == parsed_way.forward_travel_mode)) && ((0 >= parsed_way.backward_speed) || - (TRAVEL_MODE_INACCESSIBLE == parsed_way.backward_travel_mode)) && + (TRAVEL_MODE_INACCESSIBLE == parsed_way.backward_travel_mode)) && (0 >= parsed_way.duration)) { // Only true if the way is specified by the speed profile return; } - if (current_way.nodes().size() <= 1) + if (input_way.nodes().size() <= 1) { // safe-guard against broken data return; } - if (std::numeric_limits::max() == current_way.id()) + if (std::numeric_limits::max() == input_way.id()) { - SimpleLogger().Write(logDEBUG) << "found bogus way with id: " << current_way.id() - << " of size " << current_way.nodes().size(); + SimpleLogger().Write(logDEBUG) << "found bogus way with id: " << input_way.id() + << " of size " << input_way.nodes().size(); return; } @@ -96,13 +98,13 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way ¤t_way, ExtractionWa { // TODO: iterate all way segments and set duration corresponding to the length of each // segment - parsed_way.forward_speed = parsed_way.duration / (current_way.nodes().size() - 1); - parsed_way.backward_speed = parsed_way.duration / (current_way.nodes().size() - 1); + parsed_way.forward_speed = parsed_way.duration / (input_way.nodes().size() - 1); + parsed_way.backward_speed = parsed_way.duration / (input_way.nodes().size() - 1); } if (std::numeric_limits::epsilon() >= std::abs(-1. - parsed_way.forward_speed)) { - SimpleLogger().Write(logDEBUG) << "found way with bogus speed, id: " << current_way.id(); + SimpleLogger().Write(logDEBUG) << "found way with bogus speed, id: " << input_way.id(); return; } @@ -119,21 +121,24 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way ¤t_way, ExtractionWa name_id = string_map_iterator->second; } - const bool split_edge = - (parsed_way.forward_speed>0) && (TRAVEL_MODE_INACCESSIBLE != parsed_way.forward_travel_mode) && - (parsed_way.backward_speed>0) && (TRAVEL_MODE_INACCESSIBLE != parsed_way.backward_travel_mode) && - ((parsed_way.forward_speed != parsed_way.backward_speed) || - (parsed_way.forward_travel_mode != parsed_way.backward_travel_mode)); + const bool split_edge = (parsed_way.forward_speed > 0) && + (TRAVEL_MODE_INACCESSIBLE != parsed_way.forward_travel_mode) && + (parsed_way.backward_speed > 0) && + (TRAVEL_MODE_INACCESSIBLE != parsed_way.backward_travel_mode) && + ((parsed_way.forward_speed != parsed_way.backward_speed) || + (parsed_way.forward_travel_mode != parsed_way.backward_travel_mode)); auto pair_wise_segment_split = [&](const osmium::NodeRef &first_node, - const osmium::NodeRef &last_node) { + const osmium::NodeRef &last_node) + { // SimpleLogger().Write() << "adding edge (" << first_node.ref() << "," << - // last_node.ref() << "), speed: " << parsed_way.speed; - external_memory.all_edges_list.push_back( - InternalExtractorEdge(first_node.ref(), - last_node.ref(), - ((split_edge || TRAVEL_MODE_INACCESSIBLE == parsed_way.backward_travel_mode) ? ExtractionWay::oneway - : ExtractionWay::bidirectional), + // last_node.ref() << "), fwd speed: " << parsed_way.forward_speed; + external_memory.all_edges_list.push_back(InternalExtractorEdge( + first_node.ref(), + last_node.ref(), + ((split_edge || TRAVEL_MODE_INACCESSIBLE == parsed_way.backward_travel_mode) + ? ExtractionWay::oneway + : ExtractionWay::bidirectional), parsed_way.forward_speed, name_id, parsed_way.roundabout, @@ -150,23 +155,25 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way ¤t_way, ExtractionWa { parsed_way.forward_travel_mode = parsed_way.backward_travel_mode; parsed_way.backward_travel_mode = TRAVEL_MODE_INACCESSIBLE; - osrm::for_each_pair(current_way.nodes().crbegin(), current_way.nodes().crend(), pair_wise_segment_split); - external_memory.used_node_id_list.push_back(current_way.nodes().front().ref()); + osrm::for_each_pair( + input_way.nodes().crbegin(), input_way.nodes().crend(), pair_wise_segment_split); + external_memory.used_node_id_list.push_back(input_way.nodes().front().ref()); } else { - osrm::for_each_pair(current_way.nodes().cbegin(), current_way.nodes().cend(), pair_wise_segment_split); - external_memory.used_node_id_list.push_back(current_way.nodes().back().ref()); + osrm::for_each_pair( + input_way.nodes().cbegin(), input_way.nodes().cend(), pair_wise_segment_split); + external_memory.used_node_id_list.push_back(input_way.nodes().back().ref()); } // The following information is needed to identify start and end segments of restrictions - // The following information is needed to identify start and end segments of restrictions + // The following information is needed to identify start and end segments of restrictions external_memory.way_start_end_id_list.push_back( - {(EdgeID)current_way.id(), - (NodeID)current_way.nodes()[0].ref(), - (NodeID)current_way.nodes()[1].ref(), - (NodeID)current_way.nodes()[current_way.nodes().size() - 2].ref(), - (NodeID)current_way.nodes().back().ref()}); + {(EdgeID)input_way.id(), + (NodeID)input_way.nodes()[0].ref(), + (NodeID)input_way.nodes()[1].ref(), + (NodeID)input_way.nodes()[input_way.nodes().size() - 2].ref(), + (NodeID)input_way.nodes().back().ref()}); if (split_edge) { // Only true if the way should be split @@ -175,7 +182,7 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way ¤t_way, ExtractionWa const osmium::NodeRef &last_node) { // SimpleLogger().Write() << "adding edge (" << last_node.ref() << "," << - // first_node.ref() << "), speed: " << parsed_way.backward_speed; + // first_node.ref() << "), bwd speed: " << parsed_way.backward_speed; external_memory.all_edges_list.push_back( InternalExtractorEdge(last_node.ref(), first_node.ref(), @@ -193,21 +200,24 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way ¤t_way, ExtractionWa if (is_opposite_way) { // SimpleLogger().Write() << "opposite2"; - osrm::for_each_pair(current_way.nodes().crbegin(), current_way.nodes().crend(), pair_wise_segment_split_2); - external_memory.used_node_id_list.push_back(current_way.nodes().front().ref()); + osrm::for_each_pair(input_way.nodes().crbegin(), + input_way.nodes().crend(), + pair_wise_segment_split_2); + external_memory.used_node_id_list.push_back(input_way.nodes().front().ref()); } else { - osrm::for_each_pair(current_way.nodes().cbegin(), current_way.nodes().cend(), pair_wise_segment_split_2); - external_memory.used_node_id_list.push_back(current_way.nodes().back().ref()); + osrm::for_each_pair(input_way.nodes().cbegin(), + input_way.nodes().cend(), + pair_wise_segment_split_2); + external_memory.used_node_id_list.push_back(input_way.nodes().back().ref()); } - external_memory.way_start_end_id_list.push_back( - {(EdgeID)current_way.id(), - (NodeID)current_way.nodes()[1].ref(), - (NodeID)current_way.nodes()[0].ref(), - (NodeID)current_way.nodes().back().ref(), - (NodeID)current_way.nodes()[current_way.nodes().size() - 2].ref()}); + {(EdgeID)input_way.id(), + (NodeID)input_way.nodes()[1].ref(), + (NodeID)input_way.nodes()[0].ref(), + (NodeID)input_way.nodes().back().ref(), + (NodeID)input_way.nodes()[input_way.nodes().size() - 2].ref()}); } } From 18f8ce69cdb75f282fdb9a45d553245fd5df7ebf Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Wed, 27 Aug 2014 16:26:14 +0200 Subject: [PATCH 22/80] remove default c'tor in ScriptingEnvironment --- Extractor/ScriptingEnvironment.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Extractor/ScriptingEnvironment.h b/Extractor/ScriptingEnvironment.h index 2b1fffead..8fee658b3 100644 --- a/Extractor/ScriptingEnvironment.h +++ b/Extractor/ScriptingEnvironment.h @@ -37,7 +37,7 @@ struct lua_State; class ScriptingEnvironment { public: - ScriptingEnvironment(); + ScriptingEnvironment() = delete; explicit ScriptingEnvironment(const char *file_name); lua_State *getLuaState(); From f9e780ed67b9e63a922ef7ecabd9cc05261afe6a Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Wed, 27 Aug 2014 16:28:03 +0200 Subject: [PATCH 23/80] add a wrapper function to work around binding a function with default parameters against LuaBind --- Extractor/ScriptingEnvironment.cpp | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/Extractor/ScriptingEnvironment.cpp b/Extractor/ScriptingEnvironment.cpp index aba05a76e..1c09db315 100644 --- a/Extractor/ScriptingEnvironment.cpp +++ b/Extractor/ScriptingEnvironment.cpp @@ -42,7 +42,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include -ScriptingEnvironment::ScriptingEnvironment() {} +// wrapper method as luabind doesn't automatically overload funcs w/ default parameters +template +auto get_value_by_key(T const& object, const char *key) -> decltype(object.get_value_by_key(key)) +{ + return object.get_value_by_key(key); +} + ScriptingEnvironment::ScriptingEnvironment(const char *file_name) : file_name(file_name) { @@ -51,8 +57,6 @@ ScriptingEnvironment::ScriptingEnvironment(const char *file_name) void ScriptingEnvironment::initLuaState(lua_State* lua_state) { - using namespace osmium; - typedef double (osmium::Location::* location_member_ptr_type)() const; luabind::open(lua_state); @@ -76,7 +80,8 @@ void ScriptingEnvironment::initLuaState(lua_State* lua_state) luabind::class_("Node") // .def("tags", &osmium::Node::tags) - .def("get_value_by_key", &osmium::Node::get_value_by_key), + .def("get_value_by_key", &osmium::Node::get_value_by_key) + .def("get_value_by_key", &get_value_by_key), luabind::class_("ResultNode") .def_readwrite("traffic_lights", &ExtractionNode::traffic_lights) @@ -84,7 +89,7 @@ void ScriptingEnvironment::initLuaState(lua_State* lua_state) luabind::class_("ResultWay") // .def(luabind::constructor<>()) - .def_readwrite("speed", &ExtractionWay::forward_speed) + .def_readwrite("forward_speed", &ExtractionWay::forward_speed) .def_readwrite("backward_speed", &ExtractionWay::backward_speed) .def_readwrite("name", &ExtractionWay::name) .def_readwrite("roundabout", &ExtractionWay::roundabout) @@ -101,6 +106,7 @@ void ScriptingEnvironment::initLuaState(lua_State* lua_state) ], luabind::class_("Way") .def("get_value_by_key", &osmium::Way::get_value_by_key) + .def("get_value_by_key", &get_value_by_key) ]; if (0 != luaL_dofile(lua_state, file_name.c_str())) From ebcdcb5f004656d3b42e498ee7a53d75076d145e Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Wed, 27 Aug 2014 16:44:40 +0200 Subject: [PATCH 24/80] port car profile --- profiles/car.lua | 199 ++++++++++++++++++++++------------------------- 1 file changed, 93 insertions(+), 106 deletions(-) diff --git a/profiles/car.lua b/profiles/car.lua index 25291a530..c137882f5 100644 --- a/profiles/car.lua +++ b/profiles/car.lua @@ -142,15 +142,14 @@ local speed_reduction = 0.8 local mode_normal = 1 local mode_ferry = 2 - -local function find_access_tag(source,access_tags_hierachy) +local function find_access_tag(source, access_tags_hierachy) for i,v in ipairs(access_tags_hierachy) do - local has_tag = source.tags:Holds(v) - if has_tag then - return source.tags:Find(v) + local access_tag = source:get_value_by_key(v, "") + if "" ~= access_tag then + return access_tag end end - return nil + return "" end function get_exceptions(vector) @@ -191,69 +190,59 @@ end -- return penalty -- end -function node_function (node) +function node_function (node, result) + -- parse access and barrier tags local access = find_access_tag(node, access_tags_hierachy) - - --flag node if it carries a traffic light - if node.tags:Holds("highway") then - if node.tags:Find("highway") == "traffic_signals" then - node.traffic_light = true; + if access ~= "" then + if access_tag_blacklist[access] then + result.barrier = true + end + else + local barrier = node:get_value_by_key("barrier") + if barrier and "" ~= barrier then + if barrier_whitelist[barrier] then + return + else + result.barrier = true + end end end - -- parse access and barrier tags - if access and access ~= "" then - if access_tag_blacklist[access] then - node.bollard = true - end - elseif node.tags:Holds("barrier") then - local barrier = node.tags:Find("barrier") - if barrier_whitelist[barrier] then - return - else - node.bollard = true - end + -- check if node is a traffic light + local tag = node:get_value_by_key("highway") + if tag and "traffic_signals" == tag then + result.traffic_lights = true; end end -function way_function (way) +function way_function (way, result) + local highway = way:get_value_by_key("highway") + local route = way:get_value_by_key("route") - local is_highway = way.tags:Holds("highway") - local is_route = way.tags:Holds("route") - - if not (is_highway or is_route) then + if not ((highway and highway ~= "") or (route and route ~= "")) then return end -- we dont route over areas - local is_area = way.tags:Holds("area") - if ignore_areas and is_area then - local area = way.tags:Find("area") - if "yes" == area then - return - end - end - - -- check if oneway tag is unsupported - local oneway = way.tags:Find("oneway") - if "reversible" == oneway then + local area = way:get_value_by_key("area") + if ignore_areas and area and "yes" == area then return end - local is_impassable = way.tags:Holds("impassable") - if is_impassable then - local impassable = way.tags:Find("impassable") - if "yes" == impassable then - return - end + -- check if oneway tag is unsupported + local oneway = way:get_value_by_key("oneway") + if oneway and "reversible" == oneway then + return end - local is_status = way.tags:Holds("status") - if is_status then - local status = way.tags:Find("status") - if "impassable" == status then - return - end + local impassable = way:get_value_by_key("impassable") + if impassable and "yes" == impassable then + return + end + + local status = way:get_value_by_key("status") + if status and "impassable" == status then + return end -- Check if we are allowed to access the way @@ -262,22 +251,18 @@ function way_function (way) return end - -- Second, parse the way according to these properties - local highway = way.tags:Find("highway") - local route = way.tags:Find("route") - -- Handling ferries and piers local route_speed = speed_profile[route] if(route_speed and route_speed > 0) then highway = route; - local duration = way.tags:Find("duration") - if durationIsValid(duration) then - way.duration = max( parseDuration(duration), 1 ); + local duration = way:get_value_by_key("duration") + if duration and durationIsValid(duration) then + result.duration = max( parseDuration(duration), 1 ); end - way.forward_mode = mode_ferry - way.backward_mode = mode_ferry - way.forward_speed = route_speed - way.backward_speed = route_speed + result.forward_mode = mode_ferry + result.backward_mode = mode_ferry + result.forward_speed = route_speed + result.backward_speed = route_speed end -- leave early of this way is not accessible @@ -285,34 +270,34 @@ function way_function (way) return end - if way.forward_speed == -1 then + if result.forward_speed == -1 then local highway_speed = speed_profile[highway] - local max_speed = parse_maxspeed( way.tags:Find("maxspeed") ) + local max_speed = parse_maxspeed( way:get_value_by_key("maxspeed") ) -- Set the avg speed on the way if it is accessible by road class if highway_speed then - if max_speed > highway_speed then - way.forward_speed = max_speed - way.backward_speed = max_speed + if max_speed and max_speed > highway_speed then + result.forward_speed = max_speed + result.backward_speed = max_speed -- max_speed = math.huge else - way.forward_speed = highway_speed - way.backward_speed = highway_speed + result.forward_speed = highway_speed + result.backward_speed = highway_speed end else -- Set the avg speed on ways that are marked accessible if access_tag_whitelist[access] then - way.forward_speed = speed_profile["default"] - way.backward_speed = speed_profile["default"] + result.forward_speed = speed_profile["default"] + result.backward_speed = speed_profile["default"] end end if 0 == max_speed then max_speed = math.huge end - way.forward_speed = min(way.forward_speed, max_speed) - way.backward_speed = min(way.backward_speed, max_speed) + result.forward_speed = min(result.forward_speed, max_speed) + result.backward_speed = min(result.backward_speed, max_speed) end - if -1 == way.forward_speed and -1 == way.backward_speed then + if -1 == result.forward_speed and -1 == result.backward_speed then return end @@ -335,72 +320,74 @@ function way_function (way) end -- parse the remaining tags - local name = way.tags:Find("name") - local ref = way.tags:Find("ref") - local junction = way.tags:Find("junction") - -- local barrier = way.tags:Find("barrier") - -- local cycleway = way.tags:Find("cycleway") - local service = way.tags:Find("service") + local name = way:get_value_by_key("name") + local ref = way:get_value_by_key("ref") + local junction = way:get_value_by_key("junction") + -- local barrier = way:get_value_by_key("barrier", "") + -- local cycleway = way:get_value_by_key("cycleway", "") + local service = way:get_value_by_key("service") -- Set the name that will be used for instructions - if "" ~= ref then - way.name = ref - elseif "" ~= name then - way.name = name + if ref and "" ~= ref then + result.name = ref + elseif name and "" ~= name then + result.name = name -- else - -- way.name = highway -- if no name exists, use way type + -- result.name = highway -- if no name exists, use way type end - if "roundabout" == junction then - way.roundabout = true; + if junction and "roundabout" == junction then + result.roundabout = true; end -- Set access restriction flag if access is allowed under certain restrictions only if access ~= "" and access_tag_restricted[access] then - way.is_access_restricted = true + result.is_access_restricted = true end -- Set access restriction flag if service is allowed under certain restrictions only - if service ~= "" and service_tag_restricted[service] then - way.is_access_restricted = true + if service and service ~= "" and service_tag_restricted[service] then + result.is_access_restricted = true end -- Set direction according to tags on way - if obey_oneway then + if obey_oneway then if oneway == "-1" then - way.forward_mode = 0 + result.forward_mode = 0 elseif oneway == "yes" or oneway == "1" or oneway == "true" or junction == "roundabout" or (highway == "motorway_link" and oneway ~="no") or (highway == "motorway" and oneway ~= "no") then - way.backward_mode = 0 + result.backward_mode = 0 end end -- Override speed settings if explicit forward/backward maxspeeds are given - local maxspeed_forward = parse_maxspeed(way.tags:Find( "maxspeed:forward")) - local maxspeed_backward = parse_maxspeed(way.tags:Find( "maxspeed:backward")) - if maxspeed_forward > 0 then - if 0 ~= way.forward_mode and 0 ~= way.backward_mode then - way.backward_speed = way.forward_speed + local maxspeed_forward = parse_maxspeed(way:get_value_by_key( "maxspeed:forward")) + local maxspeed_backward = parse_maxspeed(way:get_value_by_key( "maxspeed:backward")) + if maxspeed_forward and maxspeed_forward > 0 then + if 0 ~= result.forward_mode and 0 ~= result.backward_mode then + result.backward_speed = result.forward_speed end - way.forward_speed = maxspeed_forward + result.forward_speed = maxspeed_forward end - if maxspeed_backward > 0 then - way.backward_speed = maxspeed_backward + if maxspeed_backward and maxspeed_backward > 0 then + result.backward_speed = maxspeed_backward end -- Override general direction settings of there is a specific one for our mode of travel if ignore_in_grid[highway] then - way.ignore_in_grid = true + result.ignore_in_grid = true end -- scale speeds to get better avg driving times - way.forward_speed = way.forward_speed * speed_reduction - if way.backward_speed > 0 then - way.backward_speed = way.backward_speed*speed_reduction + if result.forward_speed > 0 then + result.forward_speed = result.forward_speed*speed_reduction + end + if result.backward_speed > 0 then + result.backward_speed = result.backward_speed*speed_reduction end end From 94a2188090a96cac44557f1a1d500c8e7aa978e3 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Wed, 27 Aug 2014 18:09:10 +0200 Subject: [PATCH 25/80] explicitly specify optional parameter --- Extractor/ScriptingEnvironment.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Extractor/ScriptingEnvironment.cpp b/Extractor/ScriptingEnvironment.cpp index 1c09db315..25021c8e6 100644 --- a/Extractor/ScriptingEnvironment.cpp +++ b/Extractor/ScriptingEnvironment.cpp @@ -46,7 +46,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. template auto get_value_by_key(T const& object, const char *key) -> decltype(object.get_value_by_key(key)) { - return object.get_value_by_key(key); + return object.get_value_by_key(key, ""); } ScriptingEnvironment::ScriptingEnvironment(const char *file_name) From 462d4c99cc04e6b8c26123f018a6888ff5d83bb4 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Wed, 27 Aug 2014 18:10:04 +0200 Subject: [PATCH 26/80] port testbot profile --- features/testbot/distance.feature | 50 +++++++++++++------------- profiles/lib/access.lua | 4 +-- profiles/testbot.lua | 60 ++++++++++++++++--------------- 3 files changed, 58 insertions(+), 56 deletions(-) diff --git a/features/testbot/distance.feature b/features/testbot/distance.feature index 1f777d24f..55b5f6416 100644 --- a/features/testbot/distance.feature +++ b/features/testbot/distance.feature @@ -145,7 +145,7 @@ Feature: Distance calculation | a | h | abcdefgh | 70m +-14 | Scenario: Geometric distances - Given a grid size of 1000 meters + Given a grid size of 100 meters Given the node map | v | w | y | a | b | c | d | | u | | | | | | e | @@ -184,30 +184,30 @@ Feature: Distance calculation When I route I should get | from | to | route | distance | - | x | a | xa | 3000m +-2 | - | x | b | xb | 3162m +-2 | - | x | c | xc | 3606m +-2 | - | x | d | xd | 4243m +-2 | - | x | e | xe | 3606m +-2 | - | x | f | xf | 3162m +-2 | - | x | g | xg | 3000m +-2 | - | x | h | xh | 3162m +-2 | - | x | i | xi | 3606m +-2 | - | x | j | xj | 4243m +-2 | - | x | k | xk | 3606m +-2 | - | x | l | xl | 3162m +-2 | - | x | m | xm | 3000m +-2 | - | x | n | xn | 3162m +-2 | - | x | o | xo | 3606m +-2 | - | x | p | xp | 4243m +-2 | - | x | q | xq | 3606m +-2 | - | x | r | xr | 3162m +-2 | - | x | s | xs | 3000m +-2 | - | x | t | xt | 3162m +-2 | - | x | u | xu | 3606m +-2 | - | x | v | xv | 4243m +-2 | - | x | w | xw | 3606m +-2 | - | x | y | xy | 3162m +-2 | + | x | a | xa | 300m +-2 | + | x | b | xb | 316m +-2 | + | x | c | xc | 360m +-2 | + | x | d | xd | 424m +-2 | + | x | e | xe | 360m +-2 | + | x | f | xf | 316m +-2 | + | x | g | xg | 300m +-2 | + | x | h | xh | 316m +-2 | + | x | i | xi | 360m +-2 | + | x | j | xj | 424m +-2 | + | x | k | xk | 360m +-2 | + | x | l | xl | 316m +-2 | + | x | m | xm | 300m +-2 | + | x | n | xn | 316m +-2 | + | x | o | xo | 360m +-2 | + | x | p | xp | 424m +-2 | + | x | q | xq | 360m +-2 | + | x | r | xr | 316m +-2 | + | x | s | xs | 300m +-2 | + | x | t | xt | 316m +-2 | + | x | u | xu | 360m +-2 | + | x | v | xv | 424m +-2 | + | x | w | xw | 360m +-2 | + | x | y | xy | 316m +-2 | @maze Scenario: Distance of a maze of short segments diff --git a/profiles/lib/access.lua b/profiles/lib/access.lua index 094db6290..c6097bfba 100644 --- a/profiles/lib/access.lua +++ b/profiles/lib/access.lua @@ -4,10 +4,10 @@ module "Access" function find_access_tag(source,access_tags_hierachy) for i,v in ipairs(access_tags_hierachy) do - local tag = source.tags:Find(v) + local tag = source:get_value_by_key(v) if tag ~= '' then return tag end end return nil -end \ No newline at end of file +end diff --git a/profiles/testbot.lua b/profiles/testbot.lua index a0b06f56d..dcf0130c2 100644 --- a/profiles/testbot.lua +++ b/profiles/testbot.lua @@ -45,46 +45,48 @@ function limit_speed(speed, limits) return speed end -function node_function (node) - local traffic_signal = node.tags:Find("highway") +function node_function (node, result) + local traffic_signal = node:get_value_by_key("highway") - if traffic_signal == "traffic_signals" then - node.traffic_light = true; + if traffic_signal and traffic_signal == "traffic_signals" then + io.write("traffic_signal\n") + result.traffic_lights = true; -- TODO: a way to set the penalty value end - return 1 end -function way_function (way) - local highway = way.tags:Find("highway") - local name = way.tags:Find("name") - local oneway = way.tags:Find("oneway") - local route = way.tags:Find("route") - local duration = way.tags:Find("duration") - local maxspeed = tonumber(way.tags:Find ( "maxspeed")) - local maxspeed_forward = tonumber(way.tags:Find( "maxspeed:forward")) - local maxspeed_backward = tonumber(way.tags:Find( "maxspeed:backward")) - local junction = way.tags:Find("junction") +function way_function (way, result) + local highway = way:get_value_by_key("highway") + local name = way:get_value_by_key("name") + local oneway = way:get_value_by_key("oneway") + local route = way:get_value_by_key("route") + local duration = way:get_value_by_key("duration") + local maxspeed = tonumber(way:get_value_by_key ( "maxspeed")) + local maxspeed_forward = tonumber(way:get_value_by_key( "maxspeed:forward")) + local maxspeed_backward = tonumber(way:get_value_by_key( "maxspeed:backward")) + local junction = way:get_value_by_key("junction") - way.name = name + if name then + result.name = name + end - if route ~= nil and durationIsValid(duration) then - way.duration = math.max( 1, parseDuration(duration) ) - way.forward_mode = 2 - way.backward_mode = 2 + if duration and durationIsValid(duration) then + result.duration = math.max( 1, parseDuration(duration) ) + result.forward_mode = 2 + result.backward_mode = 2 else local speed_forw = speed_profile[highway] or speed_profile['default'] local speed_back = speed_forw if highway == "river" then local temp_speed = speed_forw; - way.forward_mode = 3 - way.backward_mode = 4 + result.forward_mode = 3 + result.backward_mode = 4 speed_forw = temp_speed*1.5 speed_back = temp_speed/1.5 elseif highway == "steps" then - way.forward_mode = 5 - way.backward_mode = 6 + result.forward_mode = 5 + result.backward_mode = 6 end if maxspeed_forward ~= nil and maxspeed_forward > 0 then @@ -103,19 +105,19 @@ function way_function (way) end end - way.forward_speed = speed_forw - way.backward_speed = speed_back + result.forward_speed = speed_forw + result.backward_speed = speed_back end if oneway == "no" or oneway == "0" or oneway == "false" then -- nothing to do elseif oneway == "-1" then - way.forward_mode = 0 + result.forward_mode = 0 elseif oneway == "yes" or oneway == "1" or oneway == "true" or junction == "roundabout" then - way.backward_mode = 0 + result.backward_mode = 0 end if junction == 'roundabout' then - way.roundabout = true + result.roundabout = true end end From 4cddf0bf5d866cc1dc37febcd9edbb2219a46b9e Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Wed, 27 Aug 2014 18:16:00 +0200 Subject: [PATCH 27/80] replace explicit value fetching with wrapper call --- profiles/car.lua | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/profiles/car.lua b/profiles/car.lua index c137882f5..0a0c01652 100644 --- a/profiles/car.lua +++ b/profiles/car.lua @@ -144,8 +144,8 @@ local mode_ferry = 2 local function find_access_tag(source, access_tags_hierachy) for i,v in ipairs(access_tags_hierachy) do - local access_tag = source:get_value_by_key(v, "") - if "" ~= access_tag then + local access_tag = source:get_value_by_key(v) + if access_tag and "" ~= access_tag then return access_tag end end From bdc611b23a147e1cd0005b5f738eb65d0ff3dcd6 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Wed, 27 Aug 2014 18:23:22 +0200 Subject: [PATCH 28/80] port timestamp test to libosmium --- features/step_definitions/timestamp.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/features/step_definitions/timestamp.rb b/features/step_definitions/timestamp.rb index 77a614c96..ac80bee38 100644 --- a/features/step_definitions/timestamp.rb +++ b/features/step_definitions/timestamp.rb @@ -3,5 +3,5 @@ Then /^I should get a valid timestamp/ do step "response should be valid JSON" step "response should be well-formed" expect(@json['timestamp'].class).to eq(String) - expect(@json['timestamp']).to eq(OSM_TIMESTAMP) + expect(@json['timestamp']).to eq("n/a") end From 27c255c8746984fb310bec1891fcca7fda4daeed Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Wed, 27 Aug 2014 18:38:30 +0200 Subject: [PATCH 29/80] port bicycle profile --- profiles/bicycle.lua | 237 ++++++++++++++++++++-------------------- profiles/lib/access.lua | 2 +- 2 files changed, 120 insertions(+), 119 deletions(-) diff --git a/profiles/bicycle.lua b/profiles/bicycle.lua index 4f567edc9..3e8abbdf8 100644 --- a/profiles/bicycle.lua +++ b/profiles/bicycle.lua @@ -125,42 +125,42 @@ function get_exceptions(vector) end end -function node_function (node) - local barrier = node.tags:Find ("barrier") +function node_function (node, result) + local barrier = node:get_value_by_key("barrier") local access = Access.find_access_tag(node, access_tags_hierachy) - local traffic_signal = node.tags:Find("highway") + local traffic_signal = node:get_value_by_key("highway") -- flag node if it carries a traffic light - if traffic_signal == "traffic_signals" then - node.traffic_light = true + if traffic_signal and traffic_signal == "traffic_signals" then + result.traffic_lights = true end -- parse access and barrier tags if access and access ~= "" then if access_tag_blacklist[access] then - node.bollard = true + io.write("node access: " .. access .. "\n") + result.barrier = true else - node.bollard = false + result.barrier = false end elseif barrier and barrier ~= "" then if barrier_whitelist[barrier] then - node.bollard = false + result.barrier = false else - node.bollard = true + io.write("barrier access: " .. barrier .. "\n") + result.barrier = true end end - - -- return 1 end -function way_function (way) +function way_function (way, result) -- initial routability check, filters out buildings, boundaries, etc - local highway = way.tags:Find("highway") - local route = way.tags:Find("route") - local man_made = way.tags:Find("man_made") - local railway = way.tags:Find("railway") - local amenity = way.tags:Find("amenity") - local public_transport = way.tags:Find("public_transport") + local highway = way:get_value_by_key("highway") + local route = way:get_value_by_key("route") + local man_made = way:get_value_by_key("man_made") + local railway = way:get_value_by_key("railway") + local amenity = way:get_value_by_key("amenity") + local public_transport = way:get_value_by_key("public_transport") if (not highway or highway == '') and (not route or route == '') and (not railway or railway=='') and @@ -178,117 +178,118 @@ function way_function (way) -- access local access = Access.find_access_tag(way, access_tags_hierachy) - if access_tag_blacklist[access] then + if access and access_tag_blacklist[access] then + io.write("skipping " .. access .. "\n") return end -- other tags - local name = way.tags:Find("name") - local ref = way.tags:Find("ref") - local junction = way.tags:Find("junction") - local maxspeed = parse_maxspeed(way.tags:Find ( "maxspeed") ) - local maxspeed_forward = parse_maxspeed(way.tags:Find( "maxspeed:forward")) - local maxspeed_backward = parse_maxspeed(way.tags:Find( "maxspeed:backward")) - local barrier = way.tags:Find("barrier") - local oneway = way.tags:Find("oneway") - local onewayClass = way.tags:Find("oneway:bicycle") - local cycleway = way.tags:Find("cycleway") - local cycleway_left = way.tags:Find("cycleway:left") - local cycleway_right = way.tags:Find("cycleway:right") - local duration = way.tags:Find("duration") - local service = way.tags:Find("service") - local area = way.tags:Find("area") - local foot = way.tags:Find("foot") - local surface = way.tags:Find("surface") - local bicycle = way.tags:Find("bicycle") + local name = way:get_value_by_key("name") + local ref = way:get_value_by_key("ref") + local junction = way:get_value_by_key("junction") + local maxspeed = parse_maxspeed(way:get_value_by_key ( "maxspeed") ) + local maxspeed_forward = parse_maxspeed(way:get_value_by_key( "maxspeed:forward")) + local maxspeed_backward = parse_maxspeed(way:get_value_by_key( "maxspeed:backward")) + local barrier = way:get_value_by_key("barrier") + local oneway = way:get_value_by_key("oneway") + local onewayClass = way:get_value_by_key("oneway:bicycle") + local cycleway = way:get_value_by_key("cycleway") + local cycleway_left = way:get_value_by_key("cycleway:left") + local cycleway_right = way:get_value_by_key("cycleway:right") + local duration = way:get_value_by_key("duration") + local service = way:get_value_by_key("service") + local area = way:get_value_by_key("area") + local foot = way:get_value_by_key("foot") + local surface = way:get_value_by_key("surface") + local bicycle = way:get_value_by_key("bicycle") -- name - if "" ~= ref and "" ~= name then - way.name = name .. ' / ' .. ref - elseif "" ~= ref then - way.name = ref - elseif "" ~= name then - way.name = name - else + if ref and "" ~= ref and name and "" ~= name then + result.name = name .. ' / ' .. ref + elseif ref and "" ~= ref then + result.name = ref + elseif name and "" ~= name then + result.name = name + elseif highway then -- if no name exists, use way type -- this encoding scheme is excepted to be a temporary solution - way.name = "{highway:"..highway.."}" + result.name = "{highway:"..highway.."}" end -- roundabout handling - if "roundabout" == junction then - way.roundabout = true; + if junction and "roundabout" == junction then + result.roundabout = true; end -- speed if route_speeds[route] then -- ferries (doesn't cover routes tagged using relations) - way.forward_mode = mode_ferry - way.backward_mode = mode_ferry - way.ignore_in_grid = true - if durationIsValid(duration) then - way.duration = math.max( 1, parseDuration(duration) ) + result.forward_mode = mode_ferry + result.backward_mode = mode_ferry + result.ignore_in_grid = true + if duration and durationIsValid(duration) then + result.duration = math.max( 1, parseDuration(duration) ) else - way.forward_speed = route_speeds[route] - way.backward_speed = route_speeds[route] + result.forward_speed = route_speeds[route] + result.backward_speed = route_speeds[route] end elseif railway and platform_speeds[railway] then -- railway platforms (old tagging scheme) - way.forward_speed = platform_speeds[railway] - way.backward_speed = platform_speeds[railway] + result.forward_speed = platform_speeds[railway] + result.backward_speed = platform_speeds[railway] elseif platform_speeds[public_transport] then -- public_transport platforms (new tagging platform) - way.forward_speed = platform_speeds[public_transport] - way.backward_speed = platform_speeds[public_transport] + result.forward_speed = platform_speeds[public_transport] + result.backward_speed = platform_speeds[public_transport] elseif railway and railway_speeds[railway] then - way.forward_mode = mode_train - way.backward_mode = mode_train + result.forward_mode = mode_train + result.backward_mode = mode_train -- railways if access and access_tag_whitelist[access] then - way.forward_speed = railway_speeds[railway] - way.backward_speed = railway_speeds[railway] + result.forward_speed = railway_speeds[railway] + result.backward_speed = railway_speeds[railway] end elseif amenity and amenity_speeds[amenity] then -- parking areas - way.forward_speed = amenity_speeds[amenity] - way.backward_speed = amenity_speeds[amenity] + result.forward_speed = amenity_speeds[amenity] + result.backward_speed = amenity_speeds[amenity] elseif bicycle_speeds[highway] then -- regular ways - way.forward_speed = bicycle_speeds[highway] - way.backward_speed = bicycle_speeds[highway] + result.forward_speed = bicycle_speeds[highway] + result.backward_speed = bicycle_speeds[highway] elseif access and access_tag_whitelist[access] then -- unknown way, but valid access tag - way.forward_speed = default_speed - way.backward_speed = default_speed + result.forward_speed = default_speed + result.backward_speed = default_speed else -- biking not allowed, maybe we can push our bike? -- essentially requires pedestrian profiling, for example foot=no mean we can't push a bike if foot ~= 'no' and junction ~= "roundabout" then if pedestrian_speeds[highway] then -- pedestrian-only ways and areas - way.forward_speed = pedestrian_speeds[highway] - way.backward_speed = pedestrian_speeds[highway] - way.forward_mode = mode_pushing - way.backward_mode = mode_pushing + result.forward_speed = pedestrian_speeds[highway] + result.backward_speed = pedestrian_speeds[highway] + result.forward_mode = mode_pushing + result.backward_mode = mode_pushing elseif man_made and man_made_speeds[man_made] then -- man made structures - way.forward_speed = man_made_speeds[man_made] - way.backward_speed = man_made_speeds[man_made] - way.forward_mode = mode_pushing - way.backward_mode = mode_pushing + result.forward_speed = man_made_speeds[man_made] + result.backward_speed = man_made_speeds[man_made] + result.forward_mode = mode_pushing + result.backward_mode = mode_pushing elseif foot == 'yes' then - way.forward_speed = walking_speed - way.backward_speed = walking_speed - way.forward_mode = mode_pushing - way.backward_mode = mode_pushing + result.forward_speed = walking_speed + result.backward_speed = walking_speed + result.forward_mode = mode_pushing + result.backward_mode = mode_pushing elseif foot_forward == 'yes' then - way.forward_speed = walking_speed - way.forward_mode = mode_pushing - way.backward_mode = 0 + result.forward_speed = walking_speed + result.forward_mode = mode_pushing + result.backward_mode = 0 elseif foot_backward == 'yes' then - way.forward_speed = walking_speed - way.forward_mode = 0 - way.backward_mode = mode_pushing + result.forward_speed = walking_speed + result.forward_mode = 0 + result.backward_mode = mode_pushing end end end @@ -300,84 +301,84 @@ function way_function (way) end if onewayClass == "yes" or onewayClass == "1" or onewayClass == "true" then - way.backward_mode = 0 + result.backward_mode = 0 elseif onewayClass == "no" or onewayClass == "0" or onewayClass == "false" then -- prevent implied oneway elseif onewayClass == "-1" then - way.forward_mode = 0 + result.forward_mode = 0 elseif oneway == "no" or oneway == "0" or oneway == "false" then -- prevent implied oneway elseif cycleway and string.find(cycleway, "opposite") == 1 then if impliedOneway then - way.forward_mode = 0 - way.backward_mode = mode_normal - way.backward_speed = bicycle_speeds["cycleway"] + result.forward_mode = 0 + result.backward_mode = mode_normal + result.backward_speed = bicycle_speeds["cycleway"] end elseif cycleway_left and cycleway_tags[cycleway_left] and cycleway_right and cycleway_tags[cycleway_right] then -- prevent implied elseif cycleway_left and cycleway_tags[cycleway_left] then if impliedOneway then - way.forward_mode = 0 - way.backward_mode = mode_normal - way.backward_speed = bicycle_speeds["cycleway"] + result.forward_mode = 0 + result.backward_mode = mode_normal + result.backward_speed = bicycle_speeds["cycleway"] end elseif cycleway_right and cycleway_tags[cycleway_right] then if impliedOneway then - way.forward_mode = mode_normal - way.backward_speed = bicycle_speeds["cycleway"] - way.backward_mode = 0 + result.forward_mode = mode_normal + result.backward_speed = bicycle_speeds["cycleway"] + result.backward_mode = 0 end elseif oneway == "-1" then - way.forward_mode = 0 + result.forward_mode = 0 elseif oneway == "yes" or oneway == "1" or oneway == "true" or impliedOneway then - way.backward_mode = 0 + result.backward_mode = 0 end - + -- pushing bikes if bicycle_speeds[highway] or pedestrian_speeds[highway] then if foot ~= "no" and junction ~= "roundabout" then - if way.backward_mode == 0 then - way.backward_speed = walking_speed - way.backward_mode = mode_pushing - elseif way.forward_mode == 0 then - way.forward_speed = walking_speed - way.forward_mode = mode_pushing + if result.backward_mode == 0 then + result.backward_speed = walking_speed + result.backward_mode = mode_pushing + elseif result.forward_mode == 0 then + result.forward_speed = walking_speed + result.forward_mode = mode_pushing end end end -- cycleways if cycleway and cycleway_tags[cycleway] then - way.forward_speed = bicycle_speeds["cycleway"] + result.forward_speed = bicycle_speeds["cycleway"] elseif cycleway_left and cycleway_tags[cycleway_left] then - way.forward_speed = bicycle_speeds["cycleway"] + result.forward_speed = bicycle_speeds["cycleway"] elseif cycleway_right and cycleway_tags[cycleway_right] then - way.forward_speed = bicycle_speeds["cycleway"] + result.forward_speed = bicycle_speeds["cycleway"] end -- dismount if bicycle == "dismount" then - way.forward_mode = mode_pushing - way.backward_mode = mode_pushing - way.forward_speed = walking_speed - way.backward_speed = walking_speed + result.forward_mode = mode_pushing + result.backward_mode = mode_pushing + result.forward_speed = walking_speed + result.backward_speed = walking_speed end -- surfaces if surface then surface_speed = surface_speeds[surface] if surface_speed then - if way.forward_speed > 0 then - way.forward_speed = surface_speed + if result.forward_speed > 0 then + result.forward_speed = surface_speed end - if way.backward_speed > 0 then - way.backward_speed = surface_speed + if result.backward_speed > 0 then + result.backward_speed = surface_speed end end end -- maxspeed - MaxSpeed.limit( way, maxspeed, maxspeed_forward, maxspeed_backward ) + MaxSpeed.limit( result, maxspeed, maxspeed_forward, maxspeed_backward ) end function turn_function (angle) diff --git a/profiles/lib/access.lua b/profiles/lib/access.lua index c6097bfba..76d2e2c89 100644 --- a/profiles/lib/access.lua +++ b/profiles/lib/access.lua @@ -5,7 +5,7 @@ module "Access" function find_access_tag(source,access_tags_hierachy) for i,v in ipairs(access_tags_hierachy) do local tag = source:get_value_by_key(v) - if tag ~= '' then + if tag and tag ~= '' then return tag end end From d79eac3e2644a9a24dc602c40bbffcf7b383d4ab Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Wed, 27 Aug 2014 18:43:07 +0200 Subject: [PATCH 30/80] port foot profile --- profiles/foot.lua | 110 +++++++++++++++++++++++----------------------- 1 file changed, 55 insertions(+), 55 deletions(-) diff --git a/profiles/foot.lua b/profiles/foot.lua index 1e7cd4ba0..5a370971a 100644 --- a/profiles/foot.lua +++ b/profiles/foot.lua @@ -73,42 +73,42 @@ function get_exceptions(vector) end end -function node_function (node) - local barrier = node.tags:Find ("barrier") +function node_function (node, result) + local barrier = node:get_value_by_key("barrier") local access = Access.find_access_tag(node, access_tags_hierachy) - local traffic_signal = node.tags:Find("highway") + local traffic_signal = node:get_value_by_key("highway") -- flag node if it carries a traffic light - if traffic_signal == "traffic_signals" then - node.traffic_light = true + if traffic_signal and traffic_signal == "traffic_signals" then + result.traffic_light = true end -- parse access and barrier tags if access and access ~= "" then if access_tag_blacklist[access] then - node.bollard = true + result.barrier = true else - node.bollard = false + result.barrier = false end elseif barrier and barrier ~= "" then if barrier_whitelist[barrier] then - node.bollard = false + result.barrier = false else - node.bollard = true + result.barrier = true end end return 1 end -function way_function (way) +function way_function (way, result) -- initial routability check, filters out buildings, boundaries, etc - local highway = way.tags:Find("highway") - local route = way.tags:Find("route") - local man_made = way.tags:Find("man_made") - local railway = way.tags:Find("railway") - local amenity = way.tags:Find("amenity") - local public_transport = way.tags:Find("public_transport") + local highway = way:get_value_by_key("highway") + local route = way:get_value_by_key("route") + local man_made = way:get_value_by_key("man_made") + local railway = way:get_value_by_key("railway") + local amenity = way:get_value_by_key("amenity") + local public_transport = way:get_value_by_key("public_transport") if (not highway or highway == '') and (not route or route == '') and (not railway or railway=='') and @@ -130,82 +130,82 @@ function way_function (way) return end - local name = way.tags:Find("name") - local ref = way.tags:Find("ref") - local junction = way.tags:Find("junction") - local onewayClass = way.tags:Find("oneway:foot") - local duration = way.tags:Find("duration") - local service = way.tags:Find("service") - local area = way.tags:Find("area") - local foot = way.tags:Find("foot") - local surface = way.tags:Find("surface") + local name = way:get_value_by_key("name") + local ref = way:get_value_by_key("ref") + local junction = way:get_value_by_key("junction") + local onewayClass = way:get_value_by_key("oneway:foot") + local duration = way:get_value_by_key("duration") + local service = way:get_value_by_key("service") + local area = way:get_value_by_key("area") + local foot = way:get_value_by_key("foot") + local surface = way:get_value_by_key("surface") -- name - if "" ~= ref and "" ~= name then - way.name = name .. ' / ' .. ref - elseif "" ~= ref then - way.name = ref - elseif "" ~= name then - way.name = name - else - way.name = "{highway:"..highway.."}" -- if no name exists, use way type + if ref and "" ~= ref and name and "" ~= name then + result.name = name .. ' / ' .. ref + elseif ref and "" ~= ref then + result.name = ref + elseif name and "" ~= name then + result.name = name + elseif highway then + result.name = "{highway:"..highway.."}" -- if no name exists, use way type -- this encoding scheme is excepted to be a temporary solution end -- roundabouts if "roundabout" == junction then - way.roundabout = true; + result.roundabout = true; end -- speed if route_speeds[route] then -- ferries (doesn't cover routes tagged using relations) - way.ignore_in_grid = true - if durationIsValid(duration) then - way.duration = math.max( 1, parseDuration(duration) ) + result.ignore_in_grid = true + if duration and durationIsValid(duration) then + result.duration = math.max( 1, parseDuration(duration) ) else - way.forward_speed = route_speeds[route] - way.backward_speed = route_speeds[route] + result.forward_speed = route_speeds[route] + result.backward_speed = route_speeds[route] end - way.forward_mode = mode_ferry - way.backward_mode = mode_ferry + result.forward_mode = mode_ferry + result.backward_mode = mode_ferry elseif railway and platform_speeds[railway] then -- railway platforms (old tagging scheme) - way.forward_speed = platform_speeds[railway] - way.backward_speed = platform_speeds[railway] + result.forward_speed = platform_speeds[railway] + result.backward_speed = platform_speeds[railway] elseif platform_speeds[public_transport] then -- public_transport platforms (new tagging platform) - way.forward_speed = platform_speeds[public_transport] - way.backward_speed = platform_speeds[public_transport] + result.forward_speed = platform_speeds[public_transport] + result.backward_speed = platform_speeds[public_transport] elseif amenity and amenity_speeds[amenity] then -- parking areas - way.forward_speed = amenity_speeds[amenity] - way.backward_speed = amenity_speeds[amenity] + result.forward_speed = amenity_speeds[amenity] + result.backward_speed = amenity_speeds[amenity] elseif speeds[highway] then -- regular ways - way.forward_speed = speeds[highway] - way.backward_speed = speeds[highway] + result.forward_speed = speeds[highway] + result.backward_speed = speeds[highway] elseif access and access_tag_whitelist[access] then -- unknown way, but valid access tag - way.forward_speed = walking_speed - way.backward_speed = walking_speed + result.forward_speed = walking_speed + result.backward_speed = walking_speed end -- oneway if onewayClass == "yes" or onewayClass == "1" or onewayClass == "true" then - way.backward_mode = 0 + result.backward_mode = 0 elseif onewayClass == "no" or onewayClass == "0" or onewayClass == "false" then -- nothing to do elseif onewayClass == "-1" then - way.forward_mode = 0 + result.forward_mode = 0 end -- surfaces if surface then surface_speed = surface_speeds[surface] if surface_speed then - way.forward_speed = math.min(way.forward_speed, surface_speed) - way.backward_speed = math.min(way.backward_speed, surface_speed) + result.forward_speed = math.min(result.forward_speed, surface_speed) + result.backward_speed = math.min(result.backward_speed, surface_speed) end end end From 7b57068f6f748be49f4c354d32d03db39cea4e44 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Wed, 27 Aug 2014 19:05:39 +0200 Subject: [PATCH 31/80] manually install osmpbf, the one on Travis is outdated --- .travis.yml | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/.travis.yml b/.travis.yml index 8ac2bf878..643e00dff 100644 --- a/.travis.yml +++ b/.travis.yml @@ -7,15 +7,17 @@ install: - sudo apt-add-repository -y ppa:ubuntu-toolchain-r/test - sudo add-apt-repository -y ppa:boost-latest/ppa - sudo apt-get update >/dev/null - - sudo apt-get -q install protobuf-compiler libprotoc-dev libprotobuf7 libprotobuf-dev libosmpbf-dev libbz2-dev libstxxl-dev libstxxl1 libxml2-dev libzip-dev lua5.1 liblua5.1-0-dev rubygems libtbb-dev + - sudo apt-get -q install protobuf-compiler libprotoc-dev libprotobuf7 libprotobuf-dev libbz2-dev libstxxl-dev libstxxl1 libxml2-dev libzip-dev lua5.1 liblua5.1-0-dev rubygems libtbb-dev - sudo apt-get -q install g++-4.8 - sudo apt-get install libboost1.54-all-dev - #luabind + # luabind - curl https://gist.githubusercontent.com/DennisOSRM/f2eb7b948e6fe1ae319e/raw/install-luabind.sh | sudo bash - #osmosis + # osmosis - curl -s https://gist.githubusercontent.com/DennisOSRM/803a64a9178ec375069f/raw/ | sudo bash - #cmake + # cmake - curl -s https://gist.githubusercontent.com/DennisOSRM/5fad9bee5c7f09fd7fc9/raw/ | sudo bash + # osmpbf library + - curl -s https://gist.githubusercontent.com/DennisOSRM/13b1b4fe38a57ead850e/raw/install_osmpbf.sh | sudo bash before_script: - rvm use 1.9.3 - gem install bundler From f95d1fa8ba6077c916e2bc0b798eb0abab992321 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Wed, 27 Aug 2014 19:18:45 +0200 Subject: [PATCH 32/80] add expat to cmake call on AppVeyor --- appveyor.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/appveyor.yml b/appveyor.yml index 14b2dad3c..319c5c218 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -38,7 +38,7 @@ build_script: - SET P=c:/projects/osrm - set TBB_INSTALL_DIR=%P%/tbb - set TBB_ARCH_PLATFORM=intel64/vc12 - - cmake .. -G "Visual Studio 12 Win64" -DCMAKE_BUILD_TYPE=%Configuration% -DBZIP2_INCLUDE_DIR=%P%/libs/include -DBZIP2_LIBRARIES=%P%/libs/lib/libbz2.lib -DCMAKE_INSTALL_PREFIX=%P%/libs -DBOOST_ROOT=%P%/boost_min -DBoost_USE_STATIC_LIBS=ON -T CTP_Nov2013 + - cmake .. -G "Visual Studio 12 Win64" -DCMAKE_BUILD_TYPE=%Configuration% -DEXPAT_INCLUDE_DIR=%P%/libs/include -DEXPAT_LIBRARY=%P%/libs/lib -DBZIP2_INCLUDE_DIR=%P%/libs/include -DBZIP2_LIBRARIES=%P%/libs/lib/libbz2.lib -DCMAKE_INSTALL_PREFIX=%P%/libs -DBOOST_ROOT=%P%/boost_min -DBoost_USE_STATIC_LIBS=ON -T CTP_Nov2013 - msbuild /clp:Verbosity=minimal /nologo OSRM.sln - msbuild /clp:Verbosity=minimal /nologo tests.vcxproj - cd %Configuration% From 7175180dc90fe03942112ff47645c3a7c719fabc Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Wed, 27 Aug 2014 19:37:10 +0200 Subject: [PATCH 33/80] remove deprecated code --- Extractor/BaseParser.cpp | 140 --------------------------------------- Extractor/BaseParser.h | 67 ------------------- 2 files changed, 207 deletions(-) delete mode 100644 Extractor/BaseParser.cpp delete mode 100644 Extractor/BaseParser.h diff --git a/Extractor/BaseParser.cpp b/Extractor/BaseParser.cpp deleted file mode 100644 index 20c864556..000000000 --- a/Extractor/BaseParser.cpp +++ /dev/null @@ -1,140 +0,0 @@ -/* - -Copyright (c) 2013, Project OSRM, Dennis Luxen, others -All rights reserved. - -Redistribution and use in source and binary forms, with or without modification, -are permitted provided that the following conditions are met: - -Redistributions of source code must retain the above copyright notice, this list -of conditions and the following disclaimer. -Redistributions in binary form must reproduce the above copyright notice, this -list of conditions and the following disclaimer in the documentation and/or -other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON -ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -*/ - -#include "BaseParser.h" -#include "ExtractionWay.h" -#include "ScriptingEnvironment.h" - -#include "../DataStructures/ImportNode.h" -#include "../Util/LuaUtil.h" -#include "../Util/OSRMException.h" -#include "../Util/simple_logger.hpp" - -#include -#include -#include -#include - -BaseParser::BaseParser(ExtractorCallbacks *extractor_callbacks, - ScriptingEnvironment &scripting_environment) - : extractor_callbacks(extractor_callbacks), - lua_state(scripting_environment.getLuaState()), - scripting_environment(scripting_environment), use_turn_restrictions(true) -{ - ReadUseRestrictionsSetting(); - ReadRestrictionExceptions(); -} - -void BaseParser::ReadUseRestrictionsSetting() -{ - if (0 != luaL_dostring(lua_state, "return use_turn_restrictions\n")) - { - use_turn_restrictions = false; - } - else if (lua_isboolean(lua_state, -1)) - { - use_turn_restrictions = lua_toboolean(lua_state, -1); - } - - if (use_turn_restrictions) - { - SimpleLogger().Write() << "Using turn restrictions"; - } - else - { - SimpleLogger().Write() << "Ignoring turn restrictions"; - } -} - -void BaseParser::ReadRestrictionExceptions() -{ - if (lua_function_exists(lua_state, "get_exceptions")) - { - // get list of turn restriction exceptions - luabind::call_function( - lua_state, "get_exceptions", boost::ref(restriction_exceptions)); - const unsigned exception_count = restriction_exceptions.size(); - SimpleLogger().Write() << "Found " << exception_count - << " exceptions to turn restrictions:"; - for (const std::string &str : restriction_exceptions) - { - SimpleLogger().Write() << " " << str; - } - } - else - { - SimpleLogger().Write() << "Found no exceptions to turn restrictions"; - } -} - -void BaseParser::report_errors(lua_State *lua_state, const int status) const -{ - if (0 != status) - { - std::cerr << "-- " << lua_tostring(lua_state, -1) << std::endl; - lua_pop(lua_state, 1); // remove error message - } -} - -void BaseParser::ParseNodeInLua(ImportNode &node, lua_State *local_lua_state) -{ - luabind::call_function(local_lua_state, "node_function", boost::ref(node)); -} - -void BaseParser::ParseWayInLua(ExtractionWay &way, lua_State *local_lua_state) -{ - luabind::call_function(local_lua_state, "way_function", boost::ref(way)); -} - -bool BaseParser::ShouldIgnoreRestriction(const std::string &except_tag_string) const -{ - // should this restriction be ignored? yes if there's an overlap between: - // a) the list of modes in the except tag of the restriction - // (except_tag_string), eg: except=bus;bicycle - // b) the lua profile defines a hierachy of modes, - // eg: [access, vehicle, bicycle] - - if (except_tag_string.empty()) - { - return false; - } - - // Be warned, this is quadratic work here, but we assume that - // only a few exceptions are actually defined. - std::vector exceptions; - boost::algorithm::split_regex(exceptions, except_tag_string, boost::regex("[;][ ]*")); - for (std::string ¤t_string : exceptions) - { - const auto string_iterator = - std::find(restriction_exceptions.begin(), restriction_exceptions.end(), current_string); - if (restriction_exceptions.end() != string_iterator) - { - return true; - } - } - return false; -} diff --git a/Extractor/BaseParser.h b/Extractor/BaseParser.h deleted file mode 100644 index b18da3431..000000000 --- a/Extractor/BaseParser.h +++ /dev/null @@ -1,67 +0,0 @@ -/* - -Copyright (c) 2013, Project OSRM, Dennis Luxen, others -All rights reserved. - -Redistribution and use in source and binary forms, with or without modification, -are permitted provided that the following conditions are met: - -Redistributions of source code must retain the above copyright notice, this list -of conditions and the following disclaimer. -Redistributions in binary form must reproduce the above copyright notice, this -list of conditions and the following disclaimer in the documentation and/or -other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON -ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -*/ - -#ifndef BASEPARSER_H_ -#define BASEPARSER_H_ - -#include -#include - -struct lua_State; -class ExtractorCallbacks; -class ScriptingEnvironment; -struct ExtractionWay; -struct ImportNode; - -class BaseParser -{ - public: - BaseParser() = delete; - BaseParser(const BaseParser &) = delete; - BaseParser(ExtractorCallbacks *extractor_callbacks, - ScriptingEnvironment &scripting_environment); - virtual ~BaseParser() {} - virtual bool ReadHeader() = 0; - virtual bool Parse() = 0; - - virtual void ParseNodeInLua(ImportNode &node, lua_State *lua_state); - virtual void ParseWayInLua(ExtractionWay &way, lua_State *lua_state); - virtual void report_errors(lua_State *lua_state, const int status) const; - - protected: - virtual void ReadUseRestrictionsSetting(); - virtual void ReadRestrictionExceptions(); - virtual bool ShouldIgnoreRestriction(const std::string &except_tag_string) const; - - ExtractorCallbacks *extractor_callbacks; - lua_State *lua_state; - ScriptingEnvironment &scripting_environment; - std::vector restriction_exceptions; - bool use_turn_restrictions; -}; - -#endif /* BASEPARSER_H_ */ From 5a1dfe9b89cd47f1dde4f19144b98d2a07f410c5 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Thu, 28 Aug 2014 10:50:42 +0200 Subject: [PATCH 34/80] include variant library from a relative path --- DataStructures/StaticRTree.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/DataStructures/StaticRTree.h b/DataStructures/StaticRTree.h index 8f3aa181b..6805ff4af 100644 --- a/DataStructures/StaticRTree.h +++ b/DataStructures/StaticRTree.h @@ -36,7 +36,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "SharedMemoryFactory.h" #include "SharedMemoryVectorWrapper.h" -#include "../ThirdParty/variant/variant.hpp" #include "../Util/floating_point.hpp" #include "../Util/MercatorUtil.h" #include "../Util/OSRMException.h" @@ -54,6 +53,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include +#include + #include #include #include From f692103c818ee562bedda2958cf56f6c2e80ecc8 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Thu, 28 Aug 2014 12:47:57 +0200 Subject: [PATCH 35/80] fix build on windows by linking against the right libs --- CMakeLists.txt | 3 +++ appveyor.yml | 2 +- typedefs.h | 1 + 3 files changed, 5 insertions(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index b38347a7f..feea68e66 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -156,6 +156,9 @@ elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") add_definitions(-DNOMINMAX) # avoid min and max macros that can break compilation add_definitions(-D_USE_MATH_DEFINES) # define M_PI add_definitions(-D_WIN32_WINNT=0x0501) + add_definitions(-DXML_STATIC) + find_library(ws2_32_LIBRARY_PATH ws2_32) + target_link_libraries(osrm-extract wsock32 ws2_32) endif() # Activate C++11 diff --git a/appveyor.yml b/appveyor.yml index 319c5c218..e86068ff2 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -38,7 +38,7 @@ build_script: - SET P=c:/projects/osrm - set TBB_INSTALL_DIR=%P%/tbb - set TBB_ARCH_PLATFORM=intel64/vc12 - - cmake .. -G "Visual Studio 12 Win64" -DCMAKE_BUILD_TYPE=%Configuration% -DEXPAT_INCLUDE_DIR=%P%/libs/include -DEXPAT_LIBRARY=%P%/libs/lib -DBZIP2_INCLUDE_DIR=%P%/libs/include -DBZIP2_LIBRARIES=%P%/libs/lib/libbz2.lib -DCMAKE_INSTALL_PREFIX=%P%/libs -DBOOST_ROOT=%P%/boost_min -DBoost_USE_STATIC_LIBS=ON -T CTP_Nov2013 + - cmake .. -G "Visual Studio 12 Win64" -DCMAKE_BUILD_TYPE=%Configuration% -DXML_STATIC -DEXPAT_INCLUDE_DIR=%P%/libs/include -DEXPAT_LIBRARY=%P%/libs/lib/libexpat.lib -DBZIP2_INCLUDE_DIR=%P%/libs/include -DBZIP2_LIBRARIES=%P%/libs/lib/libbz2.lib -DCMAKE_INSTALL_PREFIX=%P%/libs -DBOOST_ROOT=%P%/boost_min -DBoost_USE_STATIC_LIBS=ON -T CTP_Nov2013 - msbuild /clp:Verbosity=minimal /nologo OSRM.sln - msbuild /clp:Verbosity=minimal /nologo tests.vcxproj - cd %Configuration% diff --git a/typedefs.h b/typedefs.h index e45a6e8c9..d1b0a53a8 100644 --- a/typedefs.h +++ b/typedefs.h @@ -32,6 +32,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // Necessary workaround for Windows as VS doesn't implement C99 #ifdef _MSC_VER +#define WIN32_LEAN_AND_MEAN #ifndef M_PI #define M_PI 3.14159265358979323846 #endif From 7e9177cb3c614c2193f7af76862806eb5a428d27 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Thu, 28 Aug 2014 12:51:51 +0200 Subject: [PATCH 36/80] link against expat.lib --- appveyor.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/appveyor.yml b/appveyor.yml index e86068ff2..7624d3e2d 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -38,7 +38,7 @@ build_script: - SET P=c:/projects/osrm - set TBB_INSTALL_DIR=%P%/tbb - set TBB_ARCH_PLATFORM=intel64/vc12 - - cmake .. -G "Visual Studio 12 Win64" -DCMAKE_BUILD_TYPE=%Configuration% -DXML_STATIC -DEXPAT_INCLUDE_DIR=%P%/libs/include -DEXPAT_LIBRARY=%P%/libs/lib/libexpat.lib -DBZIP2_INCLUDE_DIR=%P%/libs/include -DBZIP2_LIBRARIES=%P%/libs/lib/libbz2.lib -DCMAKE_INSTALL_PREFIX=%P%/libs -DBOOST_ROOT=%P%/boost_min -DBoost_USE_STATIC_LIBS=ON -T CTP_Nov2013 + - cmake .. -G "Visual Studio 12 Win64" -DCMAKE_BUILD_TYPE=%Configuration% -DXML_STATIC -DEXPAT_INCLUDE_DIR=%P%/libs/include -DEXPAT_LIBRARY=%P%/libs/lib/expat.lib -DBZIP2_INCLUDE_DIR=%P%/libs/include -DBZIP2_LIBRARIES=%P%/libs/lib/libbz2.lib -DCMAKE_INSTALL_PREFIX=%P%/libs -DBOOST_ROOT=%P%/boost_min -DBoost_USE_STATIC_LIBS=ON -T CTP_Nov2013 - msbuild /clp:Verbosity=minimal /nologo OSRM.sln - msbuild /clp:Verbosity=minimal /nologo tests.vcxproj - cd %Configuration% From 3c28932862d151823e01270f9ed566e3acfccb37 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Thu, 28 Aug 2014 13:07:16 +0200 Subject: [PATCH 37/80] remove errenous define in AppVeyor cmake call --- appveyor.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/appveyor.yml b/appveyor.yml index 7624d3e2d..5548d2376 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -38,7 +38,7 @@ build_script: - SET P=c:/projects/osrm - set TBB_INSTALL_DIR=%P%/tbb - set TBB_ARCH_PLATFORM=intel64/vc12 - - cmake .. -G "Visual Studio 12 Win64" -DCMAKE_BUILD_TYPE=%Configuration% -DXML_STATIC -DEXPAT_INCLUDE_DIR=%P%/libs/include -DEXPAT_LIBRARY=%P%/libs/lib/expat.lib -DBZIP2_INCLUDE_DIR=%P%/libs/include -DBZIP2_LIBRARIES=%P%/libs/lib/libbz2.lib -DCMAKE_INSTALL_PREFIX=%P%/libs -DBOOST_ROOT=%P%/boost_min -DBoost_USE_STATIC_LIBS=ON -T CTP_Nov2013 + - cmake .. -G "Visual Studio 12 Win64" -DCMAKE_BUILD_TYPE=%Configuration% -DEXPAT_INCLUDE_DIR=%P%/libs/include -DEXPAT_LIBRARY=%P%/libs/lib/expat.lib -DBZIP2_INCLUDE_DIR=%P%/libs/include -DBZIP2_LIBRARIES=%P%/libs/lib/libbz2.lib -DCMAKE_INSTALL_PREFIX=%P%/libs -DBOOST_ROOT=%P%/boost_min -DBoost_USE_STATIC_LIBS=ON -T CTP_Nov2013 - msbuild /clp:Verbosity=minimal /nologo OSRM.sln - msbuild /clp:Verbosity=minimal /nologo tests.vcxproj - cd %Configuration% From d4d2d127d11a26d734659cd31b91af4643d162f7 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Thu, 28 Aug 2014 19:40:59 +0200 Subject: [PATCH 38/80] pass an rvalue of a parsed node into the external memory storage --- Extractor/ExtractorCallbacks.cpp | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/Extractor/ExtractorCallbacks.cpp b/Extractor/ExtractorCallbacks.cpp index dd57250c2..775afabcc 100644 --- a/Extractor/ExtractorCallbacks.cpp +++ b/Extractor/ExtractorCallbacks.cpp @@ -51,14 +51,13 @@ ExtractorCallbacks::ExtractorCallbacks(ExtractionContainers &extraction_containe void ExtractorCallbacks::ProcessNode(const osmium::Node &osm_input_node, const ExtractionNode &result_node) { - // TODO: use in-place c'tion - ExternalMemoryNode node; - node.bollard = result_node.barrier; - node.trafficLight = result_node.traffic_lights; - node.lat = osm_input_node.location().lat() * COORDINATE_PRECISION; - node.lon = osm_input_node.location().lon() * COORDINATE_PRECISION; - node.node_id = osm_input_node.id(); - external_memory.all_nodes_list.push_back(node); + external_memory.all_nodes_list.push_back({ + static_cast(osm_input_node.location().lat() * COORDINATE_PRECISION), + static_cast(osm_input_node.location().lon() * COORDINATE_PRECISION), + static_cast(osm_input_node.id()), + result_node.barrier, + result_node.traffic_lights + }); } void ExtractorCallbacks::ProcessRestriction( From 22ce4c24fb023b927f3fb3de21095f1f0fc530cc Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Fri, 29 Aug 2014 09:34:05 +0200 Subject: [PATCH 39/80] move key/value wrapper function into anonymous namespace in ScriptingEnvironment --- Extractor/ScriptingEnvironment.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Extractor/ScriptingEnvironment.cpp b/Extractor/ScriptingEnvironment.cpp index 25021c8e6..c6b786d8a 100644 --- a/Extractor/ScriptingEnvironment.cpp +++ b/Extractor/ScriptingEnvironment.cpp @@ -41,13 +41,14 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include - +namespace { // wrapper method as luabind doesn't automatically overload funcs w/ default parameters template auto get_value_by_key(T const& object, const char *key) -> decltype(object.get_value_by_key(key)) { return object.get_value_by_key(key, ""); } +} ScriptingEnvironment::ScriptingEnvironment(const char *file_name) : file_name(file_name) From 55567858042e1c840ee99a923f7b412508c13213 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Fri, 29 Aug 2014 09:44:53 +0200 Subject: [PATCH 40/80] remove implicitly defined inline keywords from header-implemented functions in ExtractionWay --- Extractor/ExtractionWay.h | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/Extractor/ExtractionWay.h b/Extractor/ExtractionWay.h index 439dbd9b0..2c32a257a 100644 --- a/Extractor/ExtractionWay.h +++ b/Extractor/ExtractionWay.h @@ -39,7 +39,7 @@ struct ExtractionWay { ExtractionWay() { Clear(); } - inline void Clear() + void Clear() { forward_speed = -1; backward_speed = -1; @@ -61,7 +61,7 @@ struct ExtractionWay // These accessor methods exists to support the depreciated "way.direction" access // in LUA. Since the direction attribute was removed from ExtractionWay, the // accessors translate to/from the mode attributes. - inline void set_direction(const Directions m) + void set_direction(const Directions m) { if (Directions::oneway == m) { @@ -80,7 +80,7 @@ struct ExtractionWay } } - inline const Directions get_direction() const + const Directions get_direction() const { if (TRAVEL_MODE_INACCESSIBLE != forward_travel_mode && TRAVEL_MODE_INACCESSIBLE != backward_travel_mode) { @@ -102,10 +102,10 @@ struct ExtractionWay // These accessors exists because it's not possible to take the address of a bitfield, // and LUA therefore cannot read/write the mode attributes directly. - inline void set_forward_mode(const TravelMode m) { forward_travel_mode = m; } - inline const TravelMode get_forward_mode() const { return forward_travel_mode; } - inline void set_backward_mode(const TravelMode m) { backward_travel_mode = m; } - inline const TravelMode get_backward_mode() const { return backward_travel_mode; } + void set_forward_mode(const TravelMode m) { forward_travel_mode = m; } + const TravelMode get_forward_mode() const { return forward_travel_mode; } + void set_backward_mode(const TravelMode m) { backward_travel_mode = m; } + const TravelMode get_backward_mode() const { return backward_travel_mode; } double forward_speed; double backward_speed; From 1d25f41122caa0efb319fb5f4edde1c512389d3c Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Fri, 29 Aug 2014 10:03:49 +0200 Subject: [PATCH 41/80] remove unused code --- Util/MachineInfo.h | 57 ---------------------------------------------- 1 file changed, 57 deletions(-) delete mode 100644 Util/MachineInfo.h diff --git a/Util/MachineInfo.h b/Util/MachineInfo.h deleted file mode 100644 index a9a88a1ec..000000000 --- a/Util/MachineInfo.h +++ /dev/null @@ -1,57 +0,0 @@ -/* - -Copyright (c) 2013, Project OSRM, Dennis Luxen, others -All rights reserved. - -Redistribution and use in source and binary forms, with or without modification, -are permitted provided that the following conditions are met: - -Redistributions of source code must retain the above copyright notice, this list -of conditions and the following disclaimer. -Redistributions in binary form must reproduce the above copyright notice, this -list of conditions and the following disclaimer in the documentation and/or -other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON -ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -*/ - -#ifndef MACHINE_INFO_H -#define MACHINE_INFO_H - -enum Endianness -{ LittleEndian = 1, - BigEndian = 2 }; - -// Function is optimized to a single 'mov eax,1' on GCC, clang and icc using -O3 -Endianness GetMachineEndianness() -{ - int i(1); - char *p = (char *)&i; - if (1 == p[0]) - { - return LittleEndian; - } - return BigEndian; -} - -// Reverses Network Byte Order into something usable, compiles down to a bswap-mov combination -unsigned SwapEndian(unsigned x) -{ - if (GetMachineEndianness() == LittleEndian) - { - return ((x >> 24) | ((x << 8) & 0x00FF0000) | ((x >> 8) & 0x0000FF00) | (x << 24)); - } - return x; -} - -#endif // MACHINE_INFO_H From f452e7f9d2345ac50a0a011d64973068f2853098 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Fri, 29 Aug 2014 10:04:13 +0200 Subject: [PATCH 42/80] remove implicitly defined inline keywords from header-implemented functions in Util/ headers --- Extractor/ExtractionNode.h | 7 ++-- Util/DataStoreOptions.h | 4 +++ Util/IniFileUtil.h | 2 +- Util/LuaUtil.h | 4 +-- Util/ProgramOptions.h | 16 ++++----- Util/StringUtil.h | 10 +++--- Util/range.hpp | 72 ++++++++++++++++++++++++++++++++++++++ Util/range_algorithms.hpp | 42 ++++++++++++++++++++++ 8 files changed, 137 insertions(+), 20 deletions(-) create mode 100644 Util/range.hpp create mode 100644 Util/range_algorithms.hpp diff --git a/Extractor/ExtractionNode.h b/Extractor/ExtractionNode.h index 44b334ab8..b53321ed5 100644 --- a/Extractor/ExtractionNode.h +++ b/Extractor/ExtractionNode.h @@ -25,8 +25,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef EXTRACTION_NODE_H__ -#define EXTRACTION_NODE_H__ +#ifndef EXTRACTION_NODE_H +#define EXTRACTION_NODE_H struct ExtractionNode { @@ -38,5 +38,4 @@ struct ExtractionNode bool traffic_lights; bool barrier; }; - -#endif +#endif // EXTRACTION_NODE_H diff --git a/Util/DataStoreOptions.h b/Util/DataStoreOptions.h index f67b12d72..a591da46b 100644 --- a/Util/DataStoreOptions.h +++ b/Util/DataStoreOptions.h @@ -43,7 +43,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include // generate boost::program_options object for the routing part +<<<<<<< HEAD bool GenerateDataStoreOptions(const int argc, const char *argv[], ServerPaths &paths) +======= +bool GenerateDataStoreOptions(const int argc, const char *argv[], ServerPaths &paths, bool & springclean) +>>>>>>> remove implicitly defined inline keywords from header-implemented functions in Util/ headers { // declare a group of options that will be allowed only on command line boost::program_options::options_description generic_options("Options"); diff --git a/Util/IniFileUtil.h b/Util/IniFileUtil.h index ea1d7a13b..6e843c8d1 100644 --- a/Util/IniFileUtil.h +++ b/Util/IniFileUtil.h @@ -36,7 +36,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include // support old capitalized option names by down-casing them with a regex replace -inline std::string ReadIniFileAndLowerContents(const boost::filesystem::path &path) +std::string ReadIniFileAndLowerContents(const boost::filesystem::path &path) { boost::filesystem::fstream config_stream(path); std::string ini_file_content((std::istreambuf_iterator(config_stream)), diff --git a/Util/LuaUtil.h b/Util/LuaUtil.h index 5c502c956..d385c39b5 100644 --- a/Util/LuaUtil.h +++ b/Util/LuaUtil.h @@ -43,7 +43,7 @@ extern "C" { template void LUA_print(T output) { std::cout << "[LUA] " << output << std::endl; } // Check if the lua function is defined -inline bool lua_function_exists(lua_State *lua_state, const char *name) +bool lua_function_exists(lua_State *lua_state, const char *name) { luabind::object globals_table = luabind::globals(lua_state); luabind::object lua_function = globals_table[name]; @@ -53,7 +53,7 @@ inline bool lua_function_exists(lua_State *lua_state, const char *name) // Add the folder contain the script to the lua load path, so script can easily require() other lua // scripts inside that folder, or subfolders. // See http://lua-users.org/wiki/PackagePath for details on the package.path syntax. -inline void luaAddScriptFolderToLoadPath(lua_State *lua_state, const char *file_name) +void luaAddScriptFolderToLoadPath(lua_State *lua_state, const char *file_name) { const boost::filesystem::path profile_path(file_name); std::string folder = profile_path.parent_path().string(); diff --git a/Util/ProgramOptions.h b/Util/ProgramOptions.h index bde9766a6..2e0ec4964 100644 --- a/Util/ProgramOptions.h +++ b/Util/ProgramOptions.h @@ -144,14 +144,14 @@ inline void populate_base_path(ServerPaths &server_paths) } // generate boost::program_options object for the routing part -inline unsigned GenerateServerProgramOptions(const int argc, - const char *argv[], - ServerPaths &paths, - std::string &ip_address, - int &ip_port, - int &requested_num_threads, - bool &use_shared_memory, - bool &trial) +unsigned GenerateServerProgramOptions(const int argc, + const char *argv[], + ServerPaths &paths, + std::string &ip_address, + int &ip_port, + int &requested_num_threads, + bool &use_shared_memory, + bool &trial) { // declare a group of options that will be allowed only on command line boost::program_options::options_description generic_options("Options"); diff --git a/Util/StringUtil.h b/Util/StringUtil.h index 3c9375ca7..f0b2f018e 100644 --- a/Util/StringUtil.h +++ b/Util/StringUtil.h @@ -38,7 +38,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // precision: position after decimal point // length: maximum number of digits including comma and decimals // work with negative values to prevent overflowing when taking -value -template static inline char *printInt(char *buffer, int value) +template static char *printInt(char *buffer, int value) { bool minus = true; if (value > 0) @@ -76,7 +76,7 @@ inline void replaceAll(std::string &s, const std::string &sub, const std::string boost::replace_all(s, sub, other); } -inline std::string EscapeJSONString(const std::string &input) +std::string EscapeJSONString(const std::string &input) { std::string output; output.reserve(input.size()); @@ -120,7 +120,7 @@ static std::string originals[] = {"&", "\"", "<", ">", "'", "[", "]", "\\"}; static std::string entities[] = { "&", """, "<", ">", "'", "&91;", "&93;", " \"}; -inline std::size_t URIDecode(const std::string &input, std::string &output) +std::size_t URIDecode(const std::string &input, std::string &output) { auto src_iter = input.begin(); output.resize(input.size() + 1); @@ -144,7 +144,7 @@ inline std::size_t URIDecode(const std::string &input, std::string &output) return decoded_length; } -inline std::size_t URIDecodeInPlace(std::string &URI) { return URIDecode(URI, URI); } +std::size_t URIDecodeInPlace(std::string &URI) { return URIDecode(URI, URI); } // TODO: remove after switch to libosmium inline bool StringStartsWith(const std::string &input, const std::string &prefix) @@ -152,7 +152,7 @@ inline bool StringStartsWith(const std::string &input, const std::string &prefix return boost::starts_with(input, prefix); } -inline std::string GetRandomString() +std::string GetRandomString() { std::string s; s.resize(128); diff --git a/Util/range.hpp b/Util/range.hpp new file mode 100644 index 000000000..a057d7c92 --- /dev/null +++ b/Util/range.hpp @@ -0,0 +1,72 @@ +/* + +Copyright (c) 2013, Project OSRM, Dennis Luxen, others +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +*/ + +#ifndef RANGE_HPP_ +#define RANGE_HPP_ + +namespace osrm +{ +namespace util +{ +template class Range +{ + public: + Range(Iterator begin, Iterator end) : begin_(begin), end_(end) {} + + Iterator begin() const { return begin_; } + Iterator end() const { return end_; } + + private: + Iterator begin_; + Iterator end_; +}; + +// Convenience functions for template parameter inference, +// akin to std::make_pair. + +template Range range(Iterator begin, Iterator end) +{ + return Range(begin, end); +} + +template +Range reverse(Reversable *reversable) +{ + return Range(reversable->rbegin(), reversable->rend()); +} + +template +Range +const_reverse(const ConstReversable *const_reversable) +{ + return Range(const_reversable->crbegin(), + const_reversable->crend()); +} +} +} + +#endif // RANGE_HPP_ diff --git a/Util/range_algorithms.hpp b/Util/range_algorithms.hpp new file mode 100644 index 000000000..208236e6c --- /dev/null +++ b/Util/range_algorithms.hpp @@ -0,0 +1,42 @@ +/* + open source routing machine + Copyright (C) Dennis Luxen, others 2010 + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU AFFERO General Public License as published by +the Free Software Foundation; either version 3 of the License, or +any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU Affero General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +or see http://www.gnu.org/licenses/agpl.txt. + */ + +#ifndef RANGE_ALGORITHMS_HPP +#define RANGE_ALGORITHMS_HPP + +#include + +namespace osrm { + +template +auto max_element(const Container & c) -> decltype(std::max_element(c.begin(), c.end())) +{ + return std::max_element(c.begin(), c.end()); +} + +template +auto max_element(const Container & c) -> decltype(std::max_element(c.cbegin(), c.cend())) +{ + return std::max_element(c.cbegin(), c.cend()); +} + +} + +#endif // RANGE_ALGORITHMS_HPP From 90d191f5f8c12c6395c02de0cef7f2e3ce6a7292 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Fri, 29 Aug 2014 10:08:26 +0200 Subject: [PATCH 43/80] remove implicitly defined inline keywords from header-implemented functions in Extractor/ExtractionHelperFunctions.h --- Extractor/ExtractionHelperFunctions.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Extractor/ExtractionHelperFunctions.h b/Extractor/ExtractionHelperFunctions.h index b053338fd..ea021ba18 100644 --- a/Extractor/ExtractionHelperFunctions.h +++ b/Extractor/ExtractionHelperFunctions.h @@ -41,7 +41,7 @@ namespace qi = boost::spirit::qi; // TODO: Move into LUA -inline bool durationIsValid(const std::string &s) +bool durationIsValid(const std::string &s) { boost::regex e( "((\\d|\\d\\d):(\\d|\\d\\d):(\\d|\\d\\d))|((\\d|\\d\\d):(\\d|\\d\\d))|(\\d|\\d\\d)", @@ -53,7 +53,7 @@ inline bool durationIsValid(const std::string &s) return matched; } -inline unsigned parseDuration(const std::string &s) +unsigned parseDuration(const std::string &s) { unsigned hours = 0; unsigned minutes = 0; From 9b501276fb1a85df856f308ef86e684e0e78abbc Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Fri, 29 Aug 2014 10:56:03 +0200 Subject: [PATCH 44/80] upgrade variant dependency --- ThirdParty/variant/optional.hpp | 78 +++++++++++++++++++++++++++++++++ 1 file changed, 78 insertions(+) create mode 100644 ThirdParty/variant/optional.hpp diff --git a/ThirdParty/variant/optional.hpp b/ThirdParty/variant/optional.hpp new file mode 100644 index 000000000..7c328da34 --- /dev/null +++ b/ThirdParty/variant/optional.hpp @@ -0,0 +1,78 @@ +#ifndef MAPBOX_UTIL_OPTIONAL_HPP +#define MAPBOX_UTIL_OPTIONAL_HPP + +#include + +#include "variant.hpp" + +namespace mapbox +{ +namespace util +{ + +template class optional +{ + static_assert(!std::is_reference::value, "optional doesn't support references"); + + struct none_type + { + }; + + variant variant_; + + public: + optional() = default; + + optional(optional const &rhs) + { + if (this != &rhs) + { // protect against invalid self-assignment + variant_ = rhs.variant_; + } + } + + optional(T const &v) { variant_ = v; } + + optional &operator=(optional other) + { // note: argument passed by value! + if (this != &other) + { + swap(other); + } + return *this; + } + + explicit operator bool() const noexcept { return variant_.template is(); } + + T const &get() const { return variant_.template get(); } + T &get() { return variant_.template get(); } + + T const &operator*() const { return this->get(); } + T operator*() { return this->get(); } + + optional &operator=(T const &v) + { + variant_ = v; + return *this; + } + + optional &operator=(optional const &rhs) + { + if (this != &rhs) + { + variant_ = rhs.variant_; + } + return *this; + } + + template void emplace(Args &&... args) + { + variant_ = T{std::forward(args)...}; + } + + void reset() { variant_ = none_type{}; } +}; +} +} + +#endif From e938bd3481c2eb6a1568a273faa1d8bc4b0c7b37 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Fri, 29 Aug 2014 11:14:59 +0200 Subject: [PATCH 45/80] Revert "remove implicitly defined inline keywords from header-implemented functions in Util/ headers" This reverts commit dc35e97ae002bdfda4bc3a68507749c464cfe371. --- Server/Http/CompressionType.h | 2 +- Util/BoostFileSystemFix.h | 10 +++++----- Util/DataStoreOptions.h | 4 ---- Util/IniFileUtil.h | 2 +- Util/LuaUtil.h | 4 ++-- Util/ProgramOptions.h | 16 ++++++++-------- Util/StringUtil.h | 10 +++++----- Util/container.hpp | 4 ++-- 8 files changed, 24 insertions(+), 28 deletions(-) diff --git a/Server/Http/CompressionType.h b/Server/Http/CompressionType.h index 74d0b629b..3836cd749 100644 --- a/Server/Http/CompressionType.h +++ b/Server/Http/CompressionType.h @@ -36,6 +36,6 @@ enum CompressionType gzipRFC1952, deflateRFC1951 }; -} // namespace http +} #endif // COMPRESSION_TYPE_H diff --git a/Util/BoostFileSystemFix.h b/Util/BoostFileSystemFix.h index d7049cc2e..06f6fcc38 100644 --- a/Util/BoostFileSystemFix.h +++ b/Util/BoostFileSystemFix.h @@ -50,7 +50,7 @@ namespace filesystem // exists. The validate() function must be defined in the same namespace // as the target type, (boost::filesystem::path in this case), otherwise // it is not called -// void validate( +// inline void validate( // boost::any & v, // const std::vector & values, // boost::filesystem::path *, @@ -68,7 +68,7 @@ namespace filesystem // adapted from: // http://stackoverflow.com/questions/1746136/how-do-i-normalize-a-pathname-using-boostfilesystem -boost::filesystem::path +inline boost::filesystem::path portable_canonical(const boost::filesystem::path &relative_path, const boost::filesystem::path ¤t_path = boost::filesystem::current_path()) { @@ -115,7 +115,7 @@ portable_canonical(const boost::filesystem::path &relative_path, #if BOOST_FILESYSTEM_VERSION < 3 -path temp_directory_path() +inline path temp_directory_path() { char *buffer; buffer = tmpnam(nullptr); @@ -123,7 +123,7 @@ path temp_directory_path() return path(buffer); } -path unique_path(const path &) { return temp_directory_path(); } +inline path unique_path(const path &) { return temp_directory_path(); } #endif } @@ -133,7 +133,7 @@ path unique_path(const path &) { return temp_directory_path(); } #define BOOST_FILESYSTEM_VERSION 3 #endif -void AssertPathExists(const boost::filesystem::path &path) +inline void AssertPathExists(const boost::filesystem::path &path) { if (!boost::filesystem::is_regular_file(path)) { diff --git a/Util/DataStoreOptions.h b/Util/DataStoreOptions.h index a591da46b..f67b12d72 100644 --- a/Util/DataStoreOptions.h +++ b/Util/DataStoreOptions.h @@ -43,11 +43,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include // generate boost::program_options object for the routing part -<<<<<<< HEAD bool GenerateDataStoreOptions(const int argc, const char *argv[], ServerPaths &paths) -======= -bool GenerateDataStoreOptions(const int argc, const char *argv[], ServerPaths &paths, bool & springclean) ->>>>>>> remove implicitly defined inline keywords from header-implemented functions in Util/ headers { // declare a group of options that will be allowed only on command line boost::program_options::options_description generic_options("Options"); diff --git a/Util/IniFileUtil.h b/Util/IniFileUtil.h index 6e843c8d1..ea1d7a13b 100644 --- a/Util/IniFileUtil.h +++ b/Util/IniFileUtil.h @@ -36,7 +36,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include // support old capitalized option names by down-casing them with a regex replace -std::string ReadIniFileAndLowerContents(const boost::filesystem::path &path) +inline std::string ReadIniFileAndLowerContents(const boost::filesystem::path &path) { boost::filesystem::fstream config_stream(path); std::string ini_file_content((std::istreambuf_iterator(config_stream)), diff --git a/Util/LuaUtil.h b/Util/LuaUtil.h index d385c39b5..5c502c956 100644 --- a/Util/LuaUtil.h +++ b/Util/LuaUtil.h @@ -43,7 +43,7 @@ extern "C" { template void LUA_print(T output) { std::cout << "[LUA] " << output << std::endl; } // Check if the lua function is defined -bool lua_function_exists(lua_State *lua_state, const char *name) +inline bool lua_function_exists(lua_State *lua_state, const char *name) { luabind::object globals_table = luabind::globals(lua_state); luabind::object lua_function = globals_table[name]; @@ -53,7 +53,7 @@ bool lua_function_exists(lua_State *lua_state, const char *name) // Add the folder contain the script to the lua load path, so script can easily require() other lua // scripts inside that folder, or subfolders. // See http://lua-users.org/wiki/PackagePath for details on the package.path syntax. -void luaAddScriptFolderToLoadPath(lua_State *lua_state, const char *file_name) +inline void luaAddScriptFolderToLoadPath(lua_State *lua_state, const char *file_name) { const boost::filesystem::path profile_path(file_name); std::string folder = profile_path.parent_path().string(); diff --git a/Util/ProgramOptions.h b/Util/ProgramOptions.h index 2e0ec4964..bde9766a6 100644 --- a/Util/ProgramOptions.h +++ b/Util/ProgramOptions.h @@ -144,14 +144,14 @@ inline void populate_base_path(ServerPaths &server_paths) } // generate boost::program_options object for the routing part -unsigned GenerateServerProgramOptions(const int argc, - const char *argv[], - ServerPaths &paths, - std::string &ip_address, - int &ip_port, - int &requested_num_threads, - bool &use_shared_memory, - bool &trial) +inline unsigned GenerateServerProgramOptions(const int argc, + const char *argv[], + ServerPaths &paths, + std::string &ip_address, + int &ip_port, + int &requested_num_threads, + bool &use_shared_memory, + bool &trial) { // declare a group of options that will be allowed only on command line boost::program_options::options_description generic_options("Options"); diff --git a/Util/StringUtil.h b/Util/StringUtil.h index f0b2f018e..3c9375ca7 100644 --- a/Util/StringUtil.h +++ b/Util/StringUtil.h @@ -38,7 +38,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // precision: position after decimal point // length: maximum number of digits including comma and decimals // work with negative values to prevent overflowing when taking -value -template static char *printInt(char *buffer, int value) +template static inline char *printInt(char *buffer, int value) { bool minus = true; if (value > 0) @@ -76,7 +76,7 @@ inline void replaceAll(std::string &s, const std::string &sub, const std::string boost::replace_all(s, sub, other); } -std::string EscapeJSONString(const std::string &input) +inline std::string EscapeJSONString(const std::string &input) { std::string output; output.reserve(input.size()); @@ -120,7 +120,7 @@ static std::string originals[] = {"&", "\"", "<", ">", "'", "[", "]", "\\"}; static std::string entities[] = { "&", """, "<", ">", "'", "&91;", "&93;", " \"}; -std::size_t URIDecode(const std::string &input, std::string &output) +inline std::size_t URIDecode(const std::string &input, std::string &output) { auto src_iter = input.begin(); output.resize(input.size() + 1); @@ -144,7 +144,7 @@ std::size_t URIDecode(const std::string &input, std::string &output) return decoded_length; } -std::size_t URIDecodeInPlace(std::string &URI) { return URIDecode(URI, URI); } +inline std::size_t URIDecodeInPlace(std::string &URI) { return URIDecode(URI, URI); } // TODO: remove after switch to libosmium inline bool StringStartsWith(const std::string &input, const std::string &prefix) @@ -152,7 +152,7 @@ inline bool StringStartsWith(const std::string &input, const std::string &prefix return boost::starts_with(input, prefix); } -std::string GetRandomString() +inline std::string GetRandomString() { std::string s; s.resize(128); diff --git a/Util/container.hpp b/Util/container.hpp index 2ab3a6872..343ebe9ba 100644 --- a/Util/container.hpp +++ b/Util/container.hpp @@ -41,13 +41,13 @@ template void sort_unique_resize(std::vector &vector) vector.resize(number_of_unique_elements); } -// template void sort_unique_resize_shrink_vector(std::vector &vector) +// template inline void sort_unique_resize_shrink_vector(std::vector &vector) // { // sort_unique_resize(vector); // vector.shrink_to_fit(); // } -// template void remove_consecutive_duplicates_from_vector(std::vector &vector) +// template inline void remove_consecutive_duplicates_from_vector(std::vector &vector) // { // const auto number_of_unique_elements = std::unique(vector.begin(), vector.end()) - vector.begin(); // vector.resize(number_of_unique_elements); From 282800e6b11bbd0be6eff8fbbcbdc038a3c803b0 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Fri, 29 Aug 2014 11:27:51 +0200 Subject: [PATCH 46/80] replace boost::optional with mapbox::util::optional --- Extractor/ExtractorCallbacks.cpp | 7 +++---- Extractor/ExtractorCallbacks.h | 6 +++--- Extractor/RestrictionParser.cpp | 10 +++++----- Extractor/RestrictionParser.h | 6 ++---- 4 files changed, 13 insertions(+), 16 deletions(-) diff --git a/Extractor/ExtractorCallbacks.cpp b/Extractor/ExtractorCallbacks.cpp index 775afabcc..8647677c9 100644 --- a/Extractor/ExtractorCallbacks.cpp +++ b/Extractor/ExtractorCallbacks.cpp @@ -61,13 +61,12 @@ void ExtractorCallbacks::ProcessNode(const osmium::Node &osm_input_node, } void ExtractorCallbacks::ProcessRestriction( - const boost::optional &restriction) + const mapbox::util::optional &restriction) { - if (!restriction.is_initialized()) + if (restriction) { - return; + external_memory.restrictions_list.push_back(restriction.get()); } - external_memory.restrictions_list.push_back(restriction.get()); } /** warning: caller needs to take care of synchronization! */ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, ExtractionWay &parsed_way) diff --git a/Extractor/ExtractorCallbacks.h b/Extractor/ExtractorCallbacks.h index 692a942b9..e43b02b52 100644 --- a/Extractor/ExtractorCallbacks.h +++ b/Extractor/ExtractorCallbacks.h @@ -31,10 +31,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "ExtractionWay.h" #include "../typedefs.h" -#include - #include +#include + #include #include @@ -59,7 +59,7 @@ class ExtractorCallbacks void ProcessNode(const osmium::Node ¤t_node, const ExtractionNode &result_node); // warning: caller needs to take care of synchronization! - void ProcessRestriction(const boost::optional &restriction); + void ProcessRestriction(const mapbox::util::optional &restriction); // warning: caller needs to take care of synchronization! void ProcessWay(const osmium::Way ¤t_way, ExtractionWay &result_way); diff --git a/Extractor/RestrictionParser.cpp b/Extractor/RestrictionParser.cpp index f3ba4104a..785c4c102 100644 --- a/Extractor/RestrictionParser.cpp +++ b/Extractor/RestrictionParser.cpp @@ -89,12 +89,12 @@ void RestrictionParser::ReadRestrictionExceptions() } } -boost::optional RestrictionParser::TryParse(osmium::Relation &relation) const +mapbox::util::optional RestrictionParser::TryParse(osmium::Relation &relation) const { // return if turn restrictions should be ignored if (!use_turn_restrictions) { - return boost::optional(); + return mapbox::util::optional(); } osmium::tags::KeyPrefixFilter filter(false); @@ -108,7 +108,7 @@ boost::optional RestrictionParser::TryParse(osmium::R // if it's a restriction, continue; if (std::distance(fi_begin, fi_end) == 0) { - return boost::optional(); + return mapbox::util::optional(); } // check if the restriction should be ignored @@ -117,7 +117,7 @@ boost::optional RestrictionParser::TryParse(osmium::R { if (ShouldIgnoreRestriction(except)) { - return boost::optional(); + return mapbox::util::optional(); } } @@ -198,7 +198,7 @@ boost::optional RestrictionParser::TryParse(osmium::R // << restriction_container.restriction.via.node << "->" << restriction_container.restriction.to.node // << ">"; - return boost::optional(restriction_container); + return mapbox::util::optional(restriction_container); } bool RestrictionParser::ShouldIgnoreRestriction(const std::string &except_tag_string) const diff --git a/Extractor/RestrictionParser.h b/Extractor/RestrictionParser.h index 433a46e85..e428e6166 100644 --- a/Extractor/RestrictionParser.h +++ b/Extractor/RestrictionParser.h @@ -30,12 +30,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "../DataStructures/Restriction.h" -#include - #include #include - +#include #include #include @@ -48,7 +46,7 @@ class RestrictionParser public: RestrictionParser(ScriptingEnvironment &scripting_environment); - boost::optional TryParse(osmium::Relation& relation) const; + mapbox::util::optional TryParse(osmium::Relation& relation) const; void ReadUseRestrictionsSetting(); void ReadRestrictionExceptions(); From 7300024e13e731b7cbf7b3fd8d30bae180b303a6 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Fri, 29 Aug 2014 11:38:12 +0200 Subject: [PATCH 47/80] remove unneeded code: HashTable --- DataStructures/HashTable.h | 78 -------------------------------------- 1 file changed, 78 deletions(-) delete mode 100644 DataStructures/HashTable.h diff --git a/DataStructures/HashTable.h b/DataStructures/HashTable.h deleted file mode 100644 index 8ff468836..000000000 --- a/DataStructures/HashTable.h +++ /dev/null @@ -1,78 +0,0 @@ -/* - -Copyright (c) 2013, Project OSRM, Dennis Luxen, others -All rights reserved. - -Redistribution and use in source and binary forms, with or without modification, -are permitted provided that the following conditions are met: - -Redistributions of source code must retain the above copyright notice, this list -of conditions and the following disclaimer. -Redistributions in binary form must reproduce the above copyright notice, this -list of conditions and the following disclaimer in the documentation and/or -other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON -ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -*/ - -#ifndef HASH_TABLE_H -#define HASH_TABLE_H - -#include - -template -class HashTable -{ - private: - using KeyValPair = std::pair; - std::vector table; - - public: - HashTable() {} - - inline void Add(Key const &key, Value const &value) - { - table.emplace_back(std::move(key), std::move(value)); - } - - inline void Clear() - { - table.clear(); - } - - inline const Value Find(Key const &key) const - { - for (const auto &key_val_pair : table) - { - if (key_val_pair.first == key) - { - return key_val_pair.second; - } - } - return Value(); - } - - inline const bool Holds(Key const &key) const - { - for (const auto &key_val_pair : table) - { - if (key_val_pair.first == key) - { - return true; - } - } - return false; - } -}; - -#endif /* HASH_TABLE_H */ From a6f34d2044052bec155bd0030e40d748f0a9a249 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Fri, 29 Aug 2014 11:38:53 +0200 Subject: [PATCH 48/80] rename ImportNode.h/cpp -> ExternalMemoryNode.h/cpp --- .../{ImportNode.cpp => ExternalMemoryNode.cpp} | 12 +----------- .../{ImportNode.h => ExternalMemoryNode.h} | 8 -------- Extractor/ExtractionWay.h | 1 - Extractor/ExtractorCallbacks.cpp | 2 +- Extractor/ExtractorStructs.h | 13 +------------ Extractor/RestrictionParser.cpp | 2 +- Extractor/ScriptingEnvironment.cpp | 2 +- Server/DataStructures/BaseDataFacade.h | 2 +- Util/GraphLoader.h | 2 +- 9 files changed, 7 insertions(+), 37 deletions(-) rename DataStructures/{ImportNode.cpp => ExternalMemoryNode.cpp} (92%) rename DataStructures/{ImportNode.h => ExternalMemoryNode.h} (91%) diff --git a/DataStructures/ImportNode.cpp b/DataStructures/ExternalMemoryNode.cpp similarity index 92% rename from DataStructures/ImportNode.cpp rename to DataStructures/ExternalMemoryNode.cpp index 8975d408a..866304864 100644 --- a/DataStructures/ImportNode.cpp +++ b/DataStructures/ExternalMemoryNode.cpp @@ -25,7 +25,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#include "ImportNode.h" +#include "ExternalMemoryNode.h" #include @@ -52,13 +52,3 @@ ExternalMemoryNode ExternalMemoryNode::max_value() false, false); } - -void ImportNode::Clear() -{ - keyVals.Clear(); - lat = 0; - lon = 0; - node_id = 0; - bollard = false; - trafficLight = false; -} diff --git a/DataStructures/ImportNode.h b/DataStructures/ExternalMemoryNode.h similarity index 91% rename from DataStructures/ImportNode.h rename to DataStructures/ExternalMemoryNode.h index b8a945120..88c4187ce 100644 --- a/DataStructures/ImportNode.h +++ b/DataStructures/ExternalMemoryNode.h @@ -29,7 +29,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #define IMPORTNODE_H_ #include "QueryNode.h" -#include "../DataStructures/HashTable.h" #include @@ -47,11 +46,4 @@ struct ExternalMemoryNode : NodeInfo bool trafficLight; }; -struct ImportNode : public ExternalMemoryNode -{ - HashTable keyVals; - - inline void Clear(); -}; - #endif /* IMPORTNODE_H_ */ diff --git a/Extractor/ExtractionWay.h b/Extractor/ExtractionWay.h index 2c32a257a..740c4beaf 100644 --- a/Extractor/ExtractionWay.h +++ b/Extractor/ExtractionWay.h @@ -28,7 +28,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef EXTRACTION_WAY_H #define EXTRACTION_WAY_H -#include "../DataStructures/HashTable.h" #include "../DataStructures/TravelMode.h" #include "../typedefs.h" diff --git a/Extractor/ExtractorCallbacks.cpp b/Extractor/ExtractorCallbacks.cpp index 8647677c9..170c4437a 100644 --- a/Extractor/ExtractorCallbacks.cpp +++ b/Extractor/ExtractorCallbacks.cpp @@ -30,8 +30,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "ExtractionNode.h" #include "ExtractionWay.h" +#include "../DataStructures/ExternalMemoryNode.h" #include "../DataStructures/Restriction.h" -#include "../DataStructures/ImportNode.h" #include "../Util/container.hpp" #include "../Util/simple_logger.hpp" diff --git a/Extractor/ExtractorStructs.h b/Extractor/ExtractorStructs.h index 39c4bbf2b..f2b4e4860 100644 --- a/Extractor/ExtractorStructs.h +++ b/Extractor/ExtractorStructs.h @@ -28,23 +28,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef EXTRACTORSTRUCTS_H_ #define EXTRACTORSTRUCTS_H_ -#include "../DataStructures/HashTable.h" -#include "../DataStructures/ImportNode.h" +#include "../DataStructures/ExternalMemoryNode.h" #include "../typedefs.h" #include #include -struct ExtractorRelation -{ - ExtractorRelation() : type(unknown) {} - enum - { unknown = 0, - ferry, - turnRestriction } type; - HashTable keyVals; -}; - struct WayIDStartAndEndEdge { unsigned wayID; diff --git a/Extractor/RestrictionParser.cpp b/Extractor/RestrictionParser.cpp index 785c4c102..6fc5ca979 100644 --- a/Extractor/RestrictionParser.cpp +++ b/Extractor/RestrictionParser.cpp @@ -29,7 +29,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "ExtractionWay.h" #include "ScriptingEnvironment.h" -#include "../DataStructures/ImportNode.h" +#include "../DataStructures/ExternalMemoryNode.h" #include "../Util/LuaUtil.h" #include "../Util/OSRMException.h" #include "../Util/SimpleLogger.h" diff --git a/Extractor/ScriptingEnvironment.cpp b/Extractor/ScriptingEnvironment.cpp index c6b786d8a..b6f56592f 100644 --- a/Extractor/ScriptingEnvironment.cpp +++ b/Extractor/ScriptingEnvironment.cpp @@ -30,7 +30,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "ExtractionHelperFunctions.h" #include "ExtractionNode.h" #include "ExtractionWay.h" -#include "../DataStructures/ImportNode.h" +#include "../DataStructures/ExternalMemoryNode.h" #include "../Util/LuaUtil.h" #include "../Util/OSRMException.h" #include "../Util/simple_logger.hpp" diff --git a/Server/DataStructures/BaseDataFacade.h b/Server/DataStructures/BaseDataFacade.h index 9b77b292a..016a7fa0c 100644 --- a/Server/DataStructures/BaseDataFacade.h +++ b/Server/DataStructures/BaseDataFacade.h @@ -31,7 +31,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // Exposes all data access interfaces to the algorithms via base class ptr #include "../../DataStructures/EdgeBasedNode.h" -#include "../../DataStructures/ImportNode.h" +#include "../../DataStructures/ExternalMemoryNode.h" #include "../../DataStructures/phantom_node.hpp" #include "../../DataStructures/Range.h" #include "../../DataStructures/TurnInstructions.h" diff --git a/Util/GraphLoader.h b/Util/GraphLoader.h index 5ce600bd0..107cd65c9 100644 --- a/Util/GraphLoader.h +++ b/Util/GraphLoader.h @@ -29,7 +29,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #define GRAPHLOADER_H #include "OSRMException.h" -#include "../DataStructures/ImportNode.h" +#include "../DataStructures/ExternalMemoryNode.h" #include "../DataStructures/ImportEdge.h" #include "../DataStructures/QueryNode.h" #include "../DataStructures/Restriction.h" From becb6cf5bf03b57c0791c4c87c8784606c010e4e Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Fri, 29 Aug 2014 11:47:05 +0200 Subject: [PATCH 49/80] compile renamed object file --- CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index feea68e66..af784f754 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -52,7 +52,7 @@ configure_file( ${CMAKE_SOURCE_DIR}/Util/GitDescription.cpp ) file(GLOB ExtractorGlob Extractor/*.cpp) -file(GLOB ImporterGlob DataStructures/Import*.cpp) +file(GLOB ImporterGlob DataStructures/ImportEdge.cpp DataStructures/ExternalMemoryNode.cpp) add_library(IMPORT OBJECT ${ImporterGlob}) add_library(LOGGER OBJECT Util/simple_logger.cpp) add_library(PHANTOMNODE OBJECT DataStructures/phantom_node.cpp) From d1454075abefb50fa6a27e3ccf288c898bdb1615 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Fri, 29 Aug 2014 12:07:00 +0200 Subject: [PATCH 50/80] untangle function object code for stxxl comperators --- DataStructures/ExternalMemoryNode.cpp | 7 +++++++ DataStructures/ExternalMemoryNode.h | 16 ++++++++++++---- Extractor/ExtractionContainers.cpp | 5 ++++- Extractor/ExtractionContainers.h | 1 + Extractor/ExtractorStructs.h | 11 ----------- 5 files changed, 24 insertions(+), 16 deletions(-) diff --git a/DataStructures/ExternalMemoryNode.cpp b/DataStructures/ExternalMemoryNode.cpp index 866304864..ecdbd9d91 100644 --- a/DataStructures/ExternalMemoryNode.cpp +++ b/DataStructures/ExternalMemoryNode.cpp @@ -52,3 +52,10 @@ ExternalMemoryNode ExternalMemoryNode::max_value() false, false); } + +bool ExternalMemoryNodeSTXXLCompare::operator()(const ExternalMemoryNode &left, const ExternalMemoryNode &right) const +{ + return left.node_id < right.node_id; +} +ExternalMemoryNodeSTXXLCompare::value_type ExternalMemoryNodeSTXXLCompare::max_value() { return ExternalMemoryNode::max_value(); } +ExternalMemoryNodeSTXXLCompare::value_type ExternalMemoryNodeSTXXLCompare::min_value() { return ExternalMemoryNode::min_value(); } diff --git a/DataStructures/ExternalMemoryNode.h b/DataStructures/ExternalMemoryNode.h index 88c4187ce..90ce532a6 100644 --- a/DataStructures/ExternalMemoryNode.h +++ b/DataStructures/ExternalMemoryNode.h @@ -25,8 +25,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef IMPORTNODE_H_ -#define IMPORTNODE_H_ +#ifndef EXTERNAL_MEMORY_NODE_H__ +#define EXTERNAL_MEMORY_NODE_H__ #include "QueryNode.h" @@ -34,7 +34,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. struct ExternalMemoryNode : NodeInfo { - ExternalMemoryNode(int lat, int lon, unsigned int id, bool bollard, bool traffic_light); + ExternalMemoryNode(int lat, int lon, NodeID id, bool bollard, bool traffic_light); ExternalMemoryNode(); @@ -46,4 +46,12 @@ struct ExternalMemoryNode : NodeInfo bool trafficLight; }; -#endif /* IMPORTNODE_H_ */ +struct ExternalMemoryNodeSTXXLCompare +{ + using value_type = ExternalMemoryNode; + bool operator()(const ExternalMemoryNode &left, const ExternalMemoryNode &right) const; + value_type max_value(); + value_type min_value(); +}; + +#endif /* EXTERNAL_MEMORY_NODE_H__ */ diff --git a/Extractor/ExtractionContainers.cpp b/Extractor/ExtractionContainers.cpp index 3b39e3476..92cfcd1d6 100644 --- a/Extractor/ExtractionContainers.cpp +++ b/Extractor/ExtractionContainers.cpp @@ -82,7 +82,10 @@ void ExtractionContainers::PrepareData(const std::string &output_file_name, std::cout << "[extractor] Sorting all nodes ... " << std::flush; TIMER_START(sorting_nodes); - stxxl::sort(all_nodes_list.begin(), all_nodes_list.end(), CmpNodeByID(), stxxl_memory); + stxxl::sort(all_nodes_list.begin(), + all_nodes_list.end(), + ExternalMemoryNodeSTXXLCompare(), + stxxl_memory); TIMER_STOP(sorting_nodes); std::cout << "ok, after " << TIMER_SEC(sorting_nodes) << "s" << std::endl; diff --git a/Extractor/ExtractionContainers.h b/Extractor/ExtractionContainers.h index bfb318ba7..377f2d2cf 100644 --- a/Extractor/ExtractionContainers.h +++ b/Extractor/ExtractionContainers.h @@ -30,6 +30,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "InternalExtractorEdge.h" #include "ExtractorStructs.h" +#include "../DataStructures/ExternalMemoryNode.h" #include "../DataStructures/Restriction.h" #include "../Util/FingerPrint.h" diff --git a/Extractor/ExtractorStructs.h b/Extractor/ExtractorStructs.h index f2b4e4860..2f68b6e31 100644 --- a/Extractor/ExtractorStructs.h +++ b/Extractor/ExtractorStructs.h @@ -89,15 +89,4 @@ struct Cmp value_type min_value() { return 0x0; } }; -struct CmpNodeByID -{ - using value_type = ExternalMemoryNode; - bool operator()(const ExternalMemoryNode &left, const ExternalMemoryNode &right) const - { - return left.node_id < right.node_id; - } - value_type max_value() { return ExternalMemoryNode::max_value(); } - value_type min_value() { return ExternalMemoryNode::min_value(); } -}; - #endif /* EXTRACTORSTRUCTS_H_ */ From 4d19811026cc5b9a20a0466481f49c98f4128398 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Fri, 29 Aug 2014 12:18:44 +0200 Subject: [PATCH 51/80] apply reformatting --- DataStructures/ExternalMemoryNode.cpp | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/DataStructures/ExternalMemoryNode.cpp b/DataStructures/ExternalMemoryNode.cpp index ecdbd9d91..6a85a955d 100644 --- a/DataStructures/ExternalMemoryNode.cpp +++ b/DataStructures/ExternalMemoryNode.cpp @@ -35,9 +35,7 @@ ExternalMemoryNode::ExternalMemoryNode( { } -ExternalMemoryNode::ExternalMemoryNode() : bollard(false), trafficLight(false) -{ -} +ExternalMemoryNode::ExternalMemoryNode() : bollard(false), trafficLight(false) {} ExternalMemoryNode ExternalMemoryNode::min_value() { @@ -53,9 +51,18 @@ ExternalMemoryNode ExternalMemoryNode::max_value() false); } -bool ExternalMemoryNodeSTXXLCompare::operator()(const ExternalMemoryNode &left, const ExternalMemoryNode &right) const +bool ExternalMemoryNodeSTXXLCompare::operator()(const ExternalMemoryNode &left, + const ExternalMemoryNode &right) const { return left.node_id < right.node_id; } -ExternalMemoryNodeSTXXLCompare::value_type ExternalMemoryNodeSTXXLCompare::max_value() { return ExternalMemoryNode::max_value(); } -ExternalMemoryNodeSTXXLCompare::value_type ExternalMemoryNodeSTXXLCompare::min_value() { return ExternalMemoryNode::min_value(); } + +ExternalMemoryNodeSTXXLCompare::value_type ExternalMemoryNodeSTXXLCompare::max_value() +{ + return ExternalMemoryNode::max_value(); +} + +ExternalMemoryNodeSTXXLCompare::value_type ExternalMemoryNodeSTXXLCompare::min_value() +{ + return ExternalMemoryNode::min_value(); +} From 51c79f9784abb0eba8c4e800a9d825711b860591 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Fri, 29 Aug 2014 12:22:44 +0200 Subject: [PATCH 52/80] rename ExtractorStructs into a more telling name --- Extractor/ExtractionContainers.cpp | 11 +++- Extractor/ExtractionContainers.h | 4 +- Extractor/ExtractorStructs.h | 40 ++++++------- Extractor/FirstAndLastSegmentOfWay.h | 84 ++++++++++++++++++++++++++++ 4 files changed, 110 insertions(+), 29 deletions(-) create mode 100644 Extractor/FirstAndLastSegmentOfWay.h diff --git a/Extractor/ExtractionContainers.cpp b/Extractor/ExtractionContainers.cpp index 92cfcd1d6..55e971cb0 100644 --- a/Extractor/ExtractionContainers.cpp +++ b/Extractor/ExtractionContainers.cpp @@ -27,10 +27,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "ExtractionContainers.h" #include "ExtractionWay.h" + +#include "../DataStructures/NodeID.h" +#include "../DataStructures/RangeTable.h" + #include "../Util/OSRMException.h" #include "../Util/simple_logger.hpp" #include "../Util/TimingUtil.h" -#include "../DataStructures/RangeTable.h" #include #include @@ -92,8 +95,10 @@ void ExtractionContainers::PrepareData(const std::string &output_file_name, std::cout << "[extractor] Sorting used ways ... " << std::flush; TIMER_START(sort_ways); - stxxl::sort( - way_start_end_id_list.begin(), way_start_end_id_list.end(), CmpWayByID(), stxxl_memory); + stxxl::sort(way_start_end_id_list.begin(), + way_start_end_id_list.end(), + FirstAndLastSegmentOfWayStxxlCompare(), + stxxl_memory); TIMER_STOP(sort_ways); std::cout << "ok, after " << TIMER_SEC(sort_ways) << "s" << std::endl; diff --git a/Extractor/ExtractionContainers.h b/Extractor/ExtractionContainers.h index 377f2d2cf..f09fcc522 100644 --- a/Extractor/ExtractionContainers.h +++ b/Extractor/ExtractionContainers.h @@ -29,7 +29,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #define EXTRACTIONCONTAINERS_H_ #include "InternalExtractorEdge.h" -#include "ExtractorStructs.h" +#include "FirstAndLastSegmentOfWay.h" #include "../DataStructures/ExternalMemoryNode.h" #include "../DataStructures/Restriction.h" #include "../Util/FingerPrint.h" @@ -49,7 +49,7 @@ class ExtractionContainers using STXXLEdgeVector = stxxl::vector; using STXXLStringVector = stxxl::vector; using STXXLRestrictionsVector = stxxl::vector; - using STXXLWayIDStartEndVector = stxxl::vector; + using STXXLWayIDStartEndVector = stxxl::vector; STXXLNodeIDVector used_node_id_list; STXXLNodeVector all_nodes_list; diff --git a/Extractor/ExtractorStructs.h b/Extractor/ExtractorStructs.h index 2f68b6e31..d1c620669 100644 --- a/Extractor/ExtractorStructs.h +++ b/Extractor/ExtractorStructs.h @@ -25,8 +25,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef EXTRACTORSTRUCTS_H_ -#define EXTRACTORSTRUCTS_H_ +#ifndef FIRST_AND_LAST_SEGMENT_OF_WAY_H__ +#define FIRST_AND_LAST_SEGMENT_OF_WAY_H__ #include "../DataStructures/ExternalMemoryNode.h" #include "../typedefs.h" @@ -34,35 +34,35 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -struct WayIDStartAndEndEdge +struct FirstAndLastSegmentOfWay { - unsigned wayID; + EdgeID wayID; NodeID firstStart; NodeID firstTarget; NodeID lastStart; NodeID lastTarget; - WayIDStartAndEndEdge() + FirstAndLastSegmentOfWay() : wayID(std::numeric_limits::max()), firstStart(std::numeric_limits::max()), firstTarget(std::numeric_limits::max()), lastStart(std::numeric_limits::max()), lastTarget(std::numeric_limits::max()) { } - WayIDStartAndEndEdge(unsigned w, NodeID fs, NodeID ft, NodeID ls, NodeID lt) + FirstAndLastSegmentOfWay(unsigned w, NodeID fs, NodeID ft, NodeID ls, NodeID lt) : wayID(w), firstStart(fs), firstTarget(ft), lastStart(ls), lastTarget(lt) { } - static WayIDStartAndEndEdge min_value() + static FirstAndLastSegmentOfWay min_value() { - return WayIDStartAndEndEdge((std::numeric_limits::min)(), + return FirstAndLastSegmentOfWay((std::numeric_limits::min)(), (std::numeric_limits::min)(), (std::numeric_limits::min)(), (std::numeric_limits::min)(), (std::numeric_limits::min)()); } - static WayIDStartAndEndEdge max_value() + static FirstAndLastSegmentOfWay max_value() { - return WayIDStartAndEndEdge((std::numeric_limits::max)(), + return FirstAndLastSegmentOfWay((std::numeric_limits::max)(), (std::numeric_limits::max)(), (std::numeric_limits::max)(), (std::numeric_limits::max)(), @@ -70,23 +70,15 @@ struct WayIDStartAndEndEdge } }; -struct CmpWayByID +struct FirstAndLastSegmentOfWayStxxlCompare { - using value_type = WayIDStartAndEndEdge; - bool operator()(const WayIDStartAndEndEdge &a, const WayIDStartAndEndEdge &b) const + using value_type = FirstAndLastSegmentOfWay; + bool operator()(const FirstAndLastSegmentOfWay &a, const FirstAndLastSegmentOfWay &b) const { return a.wayID < b.wayID; } - value_type max_value() { return WayIDStartAndEndEdge::max_value(); } - value_type min_value() { return WayIDStartAndEndEdge::min_value(); } + value_type max_value() { return FirstAndLastSegmentOfWay::max_value(); } + value_type min_value() { return FirstAndLastSegmentOfWay::min_value(); } }; -struct Cmp -{ - using value_type = NodeID; - bool operator()(const NodeID left, const NodeID right) const { return left < right; } - value_type max_value() { return 0xffffffff; } - value_type min_value() { return 0x0; } -}; - -#endif /* EXTRACTORSTRUCTS_H_ */ +#endif /* FIRST_AND_LAST_SEGMENT_OF_WAY_H__ */ diff --git a/Extractor/FirstAndLastSegmentOfWay.h b/Extractor/FirstAndLastSegmentOfWay.h new file mode 100644 index 000000000..fb23e48fc --- /dev/null +++ b/Extractor/FirstAndLastSegmentOfWay.h @@ -0,0 +1,84 @@ +/* + +Copyright (c) 2013, Project OSRM, Dennis Luxen, others +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +*/ + +#ifndef EXTRACTORSTRUCTS_H_ +#define EXTRACTORSTRUCTS_H_ + +#include "../DataStructures/ExternalMemoryNode.h" +#include "../typedefs.h" + +#include +#include + +struct FirstAndLastSegmentOfWay +{ + EdgeID wayID; + NodeID firstStart; + NodeID firstTarget; + NodeID lastStart; + NodeID lastTarget; + FirstAndLastSegmentOfWay() + : wayID(std::numeric_limits::max()), firstStart(std::numeric_limits::max()), firstTarget(std::numeric_limits::max()), lastStart(std::numeric_limits::max()), + lastTarget(std::numeric_limits::max()) + { + } + + FirstAndLastSegmentOfWay(unsigned w, NodeID fs, NodeID ft, NodeID ls, NodeID lt) + : wayID(w), firstStart(fs), firstTarget(ft), lastStart(ls), lastTarget(lt) + { + } + + static FirstAndLastSegmentOfWay min_value() + { + return FirstAndLastSegmentOfWay((std::numeric_limits::min)(), + (std::numeric_limits::min)(), + (std::numeric_limits::min)(), + (std::numeric_limits::min)(), + (std::numeric_limits::min)()); + } + static FirstAndLastSegmentOfWay max_value() + { + return FirstAndLastSegmentOfWay((std::numeric_limits::max)(), + (std::numeric_limits::max)(), + (std::numeric_limits::max)(), + (std::numeric_limits::max)(), + (std::numeric_limits::max)()); + } +}; + +struct FirstAndLastSegmentOfWayStxxlCompare +{ + using value_type = FirstAndLastSegmentOfWay; + bool operator()(const FirstAndLastSegmentOfWay &a, const FirstAndLastSegmentOfWay &b) const + { + return a.wayID < b.wayID; + } + value_type max_value() { return FirstAndLastSegmentOfWay::max_value(); } + value_type min_value() { return FirstAndLastSegmentOfWay::min_value(); } +}; + +#endif /* EXTRACTORSTRUCTS_H_ */ From 874a988527f7ea812d686200f136d57107783360 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Fri, 29 Aug 2014 12:23:14 +0200 Subject: [PATCH 53/80] add dummy NodeID.h (to move into include) --- DataStructures/NodeID.h | 41 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 DataStructures/NodeID.h diff --git a/DataStructures/NodeID.h b/DataStructures/NodeID.h new file mode 100644 index 000000000..ab9d2fdf2 --- /dev/null +++ b/DataStructures/NodeID.h @@ -0,0 +1,41 @@ +/* + +Copyright (c) 2013, Project OSRM, Dennis Luxen, others +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +*/ + +#ifndef NODE_ID_H__ +#define NODE_ID_H__ + +#include "../typedefs.h" + +struct Cmp +{ + using value_type = NodeID; + bool operator()(const NodeID left, const NodeID right) const { return left < right; } + value_type max_value() { return 0xffffffff; } + value_type min_value() { return 0x0; } +}; + +#endif // NODE_ID_H__ From 4f666e4d53a440aa26b13dce2cf47e9e6dfdd4ce Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Fri, 29 Aug 2014 12:27:43 +0200 Subject: [PATCH 54/80] remove dead code --- Extractor/ExtractorStructs.h | 84 ------------------------------------ 1 file changed, 84 deletions(-) delete mode 100644 Extractor/ExtractorStructs.h diff --git a/Extractor/ExtractorStructs.h b/Extractor/ExtractorStructs.h deleted file mode 100644 index d1c620669..000000000 --- a/Extractor/ExtractorStructs.h +++ /dev/null @@ -1,84 +0,0 @@ -/* - -Copyright (c) 2013, Project OSRM, Dennis Luxen, others -All rights reserved. - -Redistribution and use in source and binary forms, with or without modification, -are permitted provided that the following conditions are met: - -Redistributions of source code must retain the above copyright notice, this list -of conditions and the following disclaimer. -Redistributions in binary form must reproduce the above copyright notice, this -list of conditions and the following disclaimer in the documentation and/or -other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON -ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -*/ - -#ifndef FIRST_AND_LAST_SEGMENT_OF_WAY_H__ -#define FIRST_AND_LAST_SEGMENT_OF_WAY_H__ - -#include "../DataStructures/ExternalMemoryNode.h" -#include "../typedefs.h" - -#include -#include - -struct FirstAndLastSegmentOfWay -{ - EdgeID wayID; - NodeID firstStart; - NodeID firstTarget; - NodeID lastStart; - NodeID lastTarget; - FirstAndLastSegmentOfWay() - : wayID(std::numeric_limits::max()), firstStart(std::numeric_limits::max()), firstTarget(std::numeric_limits::max()), lastStart(std::numeric_limits::max()), - lastTarget(std::numeric_limits::max()) - { - } - - FirstAndLastSegmentOfWay(unsigned w, NodeID fs, NodeID ft, NodeID ls, NodeID lt) - : wayID(w), firstStart(fs), firstTarget(ft), lastStart(ls), lastTarget(lt) - { - } - - static FirstAndLastSegmentOfWay min_value() - { - return FirstAndLastSegmentOfWay((std::numeric_limits::min)(), - (std::numeric_limits::min)(), - (std::numeric_limits::min)(), - (std::numeric_limits::min)(), - (std::numeric_limits::min)()); - } - static FirstAndLastSegmentOfWay max_value() - { - return FirstAndLastSegmentOfWay((std::numeric_limits::max)(), - (std::numeric_limits::max)(), - (std::numeric_limits::max)(), - (std::numeric_limits::max)(), - (std::numeric_limits::max)()); - } -}; - -struct FirstAndLastSegmentOfWayStxxlCompare -{ - using value_type = FirstAndLastSegmentOfWay; - bool operator()(const FirstAndLastSegmentOfWay &a, const FirstAndLastSegmentOfWay &b) const - { - return a.wayID < b.wayID; - } - value_type max_value() { return FirstAndLastSegmentOfWay::max_value(); } - value_type min_value() { return FirstAndLastSegmentOfWay::min_value(); } -}; - -#endif /* FIRST_AND_LAST_SEGMENT_OF_WAY_H__ */ From b4b753ce2e4c366c0662e84162f6d2b3b5efa11e Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Fri, 29 Aug 2014 12:28:10 +0200 Subject: [PATCH 55/80] rename variables in ExternalMemoryNode to be more telling and consistent --- DataStructures/ExternalMemoryNode.cpp | 6 +++--- DataStructures/ExternalMemoryNode.h | 6 +++--- Util/GraphLoader.h | 4 ++-- 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/DataStructures/ExternalMemoryNode.cpp b/DataStructures/ExternalMemoryNode.cpp index 6a85a955d..653e421af 100644 --- a/DataStructures/ExternalMemoryNode.cpp +++ b/DataStructures/ExternalMemoryNode.cpp @@ -30,12 +30,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include ExternalMemoryNode::ExternalMemoryNode( - int lat, int lon, unsigned int node_id, bool bollard, bool traffic_light) - : NodeInfo(lat, lon, node_id), bollard(bollard), trafficLight(traffic_light) + int lat, int lon, unsigned int node_id, bool barrier, bool traffic_lights) + : NodeInfo(lat, lon, node_id), barrier(barrier), traffic_lights(traffic_lights) { } -ExternalMemoryNode::ExternalMemoryNode() : bollard(false), trafficLight(false) {} +ExternalMemoryNode::ExternalMemoryNode() : barrier(false), traffic_lights(false) {} ExternalMemoryNode ExternalMemoryNode::min_value() { diff --git a/DataStructures/ExternalMemoryNode.h b/DataStructures/ExternalMemoryNode.h index 90ce532a6..a641a6d8c 100644 --- a/DataStructures/ExternalMemoryNode.h +++ b/DataStructures/ExternalMemoryNode.h @@ -34,7 +34,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. struct ExternalMemoryNode : NodeInfo { - ExternalMemoryNode(int lat, int lon, NodeID id, bool bollard, bool traffic_light); + ExternalMemoryNode(int lat, int lon, NodeID id, bool barrier, bool traffic_light); ExternalMemoryNode(); @@ -42,8 +42,8 @@ struct ExternalMemoryNode : NodeInfo static ExternalMemoryNode max_value(); - bool bollard; - bool trafficLight; + bool barrier; + bool traffic_lights; }; struct ExternalMemoryNodeSTXXLCompare diff --git a/Util/GraphLoader.h b/Util/GraphLoader.h index 107cd65c9..a7eab64f0 100644 --- a/Util/GraphLoader.h +++ b/Util/GraphLoader.h @@ -82,11 +82,11 @@ NodeID readBinaryOSRMGraphFromStream(std::istream &input_stream, input_stream.read((char *)¤t_node, sizeof(ExternalMemoryNode)); int_to_ext_node_id_map->emplace_back(current_node.lat, current_node.lon, current_node.node_id); ext_to_int_id_map.emplace(current_node.node_id, i); - if (current_node.bollard) + if (current_node.barrier) { barrier_node_list.emplace_back(i); } - if (current_node.trafficLight) + if (current_node.traffic_lights) { traffic_light_node_list.emplace_back(i); } From 0d7141ce5b472d0f37339f1ba0959a0f4e78745c Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Fri, 29 Aug 2014 12:37:07 +0200 Subject: [PATCH 56/80] Rename NodeInfo -> QueryNode --- Algorithms/StronglyConnectedComponents.h | 4 +- Benchmarks/StaticRTreeBench.cpp | 4 +- Contractor/EdgeBasedGraphFactory.h | 4 +- Contractor/Prepare.cpp | 2 +- Contractor/Prepare.h | 2 +- DataStructures/ExternalMemoryNode.cpp | 2 +- DataStructures/ExternalMemoryNode.h | 2 +- DataStructures/QueryNode.h | 22 +-- DataStructures/StaticRTree.h | 188 ++++++++++++++++++++- Server/DataStructures/InternalDataFacade.h | 4 +- Tools/components.cpp | 2 +- Util/FingerPrint.h | 1 - Util/GraphLoader.h | 2 +- datastore.cpp | 4 +- 14 files changed, 213 insertions(+), 30 deletions(-) diff --git a/Algorithms/StronglyConnectedComponents.h b/Algorithms/StronglyConnectedComponents.h index 846ed41d7..666aad9cf 100644 --- a/Algorithms/StronglyConnectedComponents.h +++ b/Algorithms/StronglyConnectedComponents.h @@ -99,7 +99,7 @@ class TarjanSCC using EmanatingRestrictionsVector = std::vector; using RestrictionMap = std::unordered_map; - std::vector m_coordinate_list; + std::vector m_coordinate_list; std::vector m_restriction_bucket_list; std::shared_ptr m_node_based_graph; std::unordered_set barrier_node_list; @@ -113,7 +113,7 @@ class TarjanSCC std::vector &bn, std::vector &tl, std::vector &irs, - std::vector &nI) + std::vector &nI) : m_coordinate_list(nI), m_restriction_counter(irs.size()) { TIMER_START(SCC_LOAD); diff --git a/Benchmarks/StaticRTreeBench.cpp b/Benchmarks/StaticRTreeBench.cpp index 4e6b2da89..e6e4f2225 100644 --- a/Benchmarks/StaticRTreeBench.cpp +++ b/Benchmarks/StaticRTreeBench.cpp @@ -24,13 +24,13 @@ FixedPointCoordinateListPtr LoadCoordinates(const boost::filesystem::path &nodes { boost::filesystem::ifstream nodes_input_stream(nodes_file, std::ios::binary); - NodeInfo current_node; + QueryNode current_node; unsigned number_of_coordinates = 0; nodes_input_stream.read((char *)&number_of_coordinates, sizeof(unsigned)); auto coords = std::make_shared>(number_of_coordinates); for (unsigned i = 0; i < number_of_coordinates; ++i) { - nodes_input_stream.read((char *)¤t_node, sizeof(NodeInfo)); + nodes_input_stream.read((char *)¤t_node, sizeof(QueryNode)); coords->at(i) = FixedPointCoordinate(current_node.lat, current_node.lon); BOOST_ASSERT((std::abs(coords->at(i).lat) >> 30) == 0); BOOST_ASSERT((std::abs(coords->at(i).lon) >> 30) == 0); diff --git a/Contractor/EdgeBasedGraphFactory.h b/Contractor/EdgeBasedGraphFactory.h index be35a199c..65aef649d 100644 --- a/Contractor/EdgeBasedGraphFactory.h +++ b/Contractor/EdgeBasedGraphFactory.h @@ -63,7 +63,7 @@ class EdgeBasedGraphFactory std::unique_ptr restricion_map, std::vector &barrier_node_list, std::vector &traffic_light_node_list, - std::vector &m_node_info_list, + std::vector &m_node_info_list, SpeedProfileProperties &speed_profile); void Run(const std::string &original_edge_data_filename, @@ -97,7 +97,7 @@ class EdgeBasedGraphFactory unsigned m_number_of_edge_based_nodes; - std::vector m_node_info_list; + std::vector m_node_info_list; std::vector m_edge_based_node_list; DeallocatingVector m_edge_based_edge_list; diff --git a/Contractor/Prepare.cpp b/Contractor/Prepare.cpp index 75daf4b39..386dc101e 100644 --- a/Contractor/Prepare.cpp +++ b/Contractor/Prepare.cpp @@ -554,7 +554,7 @@ void Prepare::WriteNodeMapping() if (size_of_mapping > 0) { node_stream.write((char *)&(internal_to_external_node_map[0]), - size_of_mapping * sizeof(NodeInfo)); + size_of_mapping * sizeof(QueryNode)); } node_stream.close(); internal_to_external_node_map.clear(); diff --git a/Contractor/Prepare.h b/Contractor/Prepare.h index 9facbb57d..3731e129a 100644 --- a/Contractor/Prepare.h +++ b/Contractor/Prepare.h @@ -42,7 +42,7 @@ class Prepare void BuildRTree(std::vector &node_based_edge_list); private: - std::vector internal_to_external_node_map; + std::vector internal_to_external_node_map; std::vector restriction_list; std::vector barrier_node_list; std::vector traffic_light_list; diff --git a/DataStructures/ExternalMemoryNode.cpp b/DataStructures/ExternalMemoryNode.cpp index 653e421af..5f22220fb 100644 --- a/DataStructures/ExternalMemoryNode.cpp +++ b/DataStructures/ExternalMemoryNode.cpp @@ -31,7 +31,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ExternalMemoryNode::ExternalMemoryNode( int lat, int lon, unsigned int node_id, bool barrier, bool traffic_lights) - : NodeInfo(lat, lon, node_id), barrier(barrier), traffic_lights(traffic_lights) + : QueryNode(lat, lon, node_id), barrier(barrier), traffic_lights(traffic_lights) { } diff --git a/DataStructures/ExternalMemoryNode.h b/DataStructures/ExternalMemoryNode.h index a641a6d8c..c65b40a1f 100644 --- a/DataStructures/ExternalMemoryNode.h +++ b/DataStructures/ExternalMemoryNode.h @@ -32,7 +32,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include -struct ExternalMemoryNode : NodeInfo +struct ExternalMemoryNode : QueryNode { ExternalMemoryNode(int lat, int lon, NodeID id, bool barrier, bool traffic_light); diff --git a/DataStructures/QueryNode.h b/DataStructures/QueryNode.h index 6ebbce46d..0d9c6ad9c 100644 --- a/DataStructures/QueryNode.h +++ b/DataStructures/QueryNode.h @@ -36,13 +36,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include -struct NodeInfo +struct QueryNode { using key_type = NodeID; // type of NodeID using value_type = int; // type of lat,lons - explicit NodeInfo(int lat, int lon, NodeID node_id) : lat(lat), lon(lon), node_id(node_id) {} - NodeInfo() + explicit QueryNode(int lat, int lon, NodeID node_id) : lat(lat), lon(lon), node_id(node_id) {} + QueryNode() : lat(std::numeric_limits::max()), lon(std::numeric_limits::max()), node_id(std::numeric_limits::max()) { @@ -52,18 +52,18 @@ struct NodeInfo int lon; NodeID node_id; - static NodeInfo min_value() + static QueryNode min_value() { - return NodeInfo(static_cast(-90 * COORDINATE_PRECISION), - static_cast(-180 * COORDINATE_PRECISION), - std::numeric_limits::min()); + return QueryNode(static_cast(-90 * COORDINATE_PRECISION), + static_cast(-180 * COORDINATE_PRECISION), + std::numeric_limits::min()); } - static NodeInfo max_value() + static QueryNode max_value() { - return NodeInfo(static_cast(90 * COORDINATE_PRECISION), - static_cast(180 * COORDINATE_PRECISION), - std::numeric_limits::max()); + return QueryNode(static_cast(90 * COORDINATE_PRECISION), + static_cast(180 * COORDINATE_PRECISION), + std::numeric_limits::max()); } value_type operator[](const std::size_t n) const diff --git a/DataStructures/StaticRTree.h b/DataStructures/StaticRTree.h index 6805ff4af..aa5bce540 100644 --- a/DataStructures/StaticRTree.h +++ b/DataStructures/StaticRTree.h @@ -72,6 +72,190 @@ template &objects, + const uint32_t element_count, + const std::vector &coordinate_list) + { + for (uint32_t i = 0; i < element_count; ++i) + { + min_lon = std::min(min_lon, + std::min(coordinate_list.at(objects[i].u).lon, + coordinate_list.at(objects[i].v).lon)); + max_lon = std::max(max_lon, + std::max(coordinate_list.at(objects[i].u).lon, + coordinate_list.at(objects[i].v).lon)); + + min_lat = std::min(min_lat, + std::min(coordinate_list.at(objects[i].u).lat, + coordinate_list.at(objects[i].v).lat)); + max_lat = std::max(max_lat, + std::max(coordinate_list.at(objects[i].u).lat, + coordinate_list.at(objects[i].v).lat)); + } + BOOST_ASSERT(min_lat != std::numeric_limits::min()); + BOOST_ASSERT(min_lon != std::numeric_limits::min()); + BOOST_ASSERT(max_lat != std::numeric_limits::min()); + BOOST_ASSERT(max_lon != std::numeric_limits::min()); + } + + inline void MergeBoundingBoxes(const RectangleInt2D &other) + { + min_lon = std::min(min_lon, other.min_lon); + max_lon = std::max(max_lon, other.max_lon); + min_lat = std::min(min_lat, other.min_lat); + max_lat = std::max(max_lat, other.max_lat); + BOOST_ASSERT(min_lat != std::numeric_limits::min()); + BOOST_ASSERT(min_lon != std::numeric_limits::min()); + BOOST_ASSERT(max_lat != std::numeric_limits::min()); + BOOST_ASSERT(max_lon != std::numeric_limits::min()); + } + + inline FixedPointCoordinate Centroid() const + { + FixedPointCoordinate centroid; + // The coordinates of the midpoints are given by: + // x = (x1 + x2) /2 and y = (y1 + y2) /2. + centroid.lon = (min_lon + max_lon) / 2; + centroid.lat = (min_lat + max_lat) / 2; + return centroid; + } + + inline bool Intersects(const RectangleInt2D &other) const + { + FixedPointCoordinate upper_left(other.max_lat, other.min_lon); + FixedPointCoordinate upper_right(other.max_lat, other.max_lon); + FixedPointCoordinate lower_right(other.min_lat, other.max_lon); + FixedPointCoordinate lower_left(other.min_lat, other.min_lon); + + return (Contains(upper_left) || Contains(upper_right) || Contains(lower_right) || + Contains(lower_left)); + } + + inline float GetMinDist(const FixedPointCoordinate &location) const + { + const bool is_contained = Contains(location); + if (is_contained) + { + return 0.; + } + + enum Direction + { + INVALID = 0, + NORTH = 1, + SOUTH = 2, + EAST = 4, + NORTH_EAST = 5, + SOUTH_EAST = 6, + WEST = 8, + NORTH_WEST = 9, + SOUTH_WEST = 10 + }; + + Direction d = INVALID; + if (location.lat > max_lat) + d = (Direction) (d | NORTH); + else if (location.lat < min_lat) + d = (Direction) (d | SOUTH); + if (location.lon > max_lon) + d = (Direction) (d | EAST); + else if (location.lon < min_lon) + d = (Direction) (d | WEST); + + BOOST_ASSERT(d != INVALID); + + float min_dist = std::numeric_limits::max(); + switch (d) + { + case NORTH: + min_dist = FixedPointCoordinate::ApproximateEuclideanDistance(location, FixedPointCoordinate(max_lat, location.lon)); + break; + case SOUTH: + min_dist = FixedPointCoordinate::ApproximateEuclideanDistance(location, FixedPointCoordinate(min_lat, location.lon)); + break; + case WEST: + min_dist = FixedPointCoordinate::ApproximateEuclideanDistance(location, FixedPointCoordinate(location.lat, min_lon)); + break; + case EAST: + min_dist = FixedPointCoordinate::ApproximateEuclideanDistance(location, FixedPointCoordinate(location.lat, max_lon)); + break; + case NORTH_EAST: + min_dist = FixedPointCoordinate::ApproximateEuclideanDistance(location, FixedPointCoordinate(max_lat, max_lon)); + break; + case NORTH_WEST: + min_dist = FixedPointCoordinate::ApproximateEuclideanDistance(location, FixedPointCoordinate(max_lat, min_lon)); + break; + case SOUTH_EAST: + min_dist = FixedPointCoordinate::ApproximateEuclideanDistance(location, FixedPointCoordinate(min_lat, max_lon)); + break; + case SOUTH_WEST: + min_dist = FixedPointCoordinate::ApproximateEuclideanDistance(location, FixedPointCoordinate(min_lat, min_lon)); + break; + default: + break; + } + + BOOST_ASSERT(min_dist != std::numeric_limits::max()); + + return min_dist; + } + + inline float GetMinMaxDist(const FixedPointCoordinate &location) const + { + float min_max_dist = std::numeric_limits::max(); + // Get minmax distance to each of the four sides + const FixedPointCoordinate upper_left(max_lat, min_lon); + const FixedPointCoordinate upper_right(max_lat, max_lon); + const FixedPointCoordinate lower_right(min_lat, max_lon); + const FixedPointCoordinate lower_left(min_lat, min_lon); + + min_max_dist = std::min( + min_max_dist, + std::max( + FixedPointCoordinate::ApproximateEuclideanDistance(location, upper_left), + FixedPointCoordinate::ApproximateEuclideanDistance(location, upper_right))); + + min_max_dist = std::min( + min_max_dist, + std::max( + FixedPointCoordinate::ApproximateEuclideanDistance(location, upper_right), + FixedPointCoordinate::ApproximateEuclideanDistance(location, lower_right))); + + min_max_dist = std::min( + min_max_dist, + std::max(FixedPointCoordinate::ApproximateEuclideanDistance(location, lower_right), + FixedPointCoordinate::ApproximateEuclideanDistance(location, lower_left))); + + min_max_dist = std::min( + min_max_dist, + std::max(FixedPointCoordinate::ApproximateEuclideanDistance(location, lower_left), + FixedPointCoordinate::ApproximateEuclideanDistance(location, upper_left))); + return min_max_dist; + } + + inline bool Contains(const FixedPointCoordinate &location) const + { + const bool lats_contained = (location.lat >= min_lat) && (location.lat <= max_lat); + const bool lons_contained = (location.lon >= min_lon) && (location.lon <= max_lon); + return lats_contained && lons_contained; + } + + inline friend std::ostream &operator<<(std::ostream &out, const RectangleInt2D &rect) + { + out << rect.min_lat / COORDINATE_PRECISION << "," << rect.min_lon / COORDINATE_PRECISION + << " " << rect.max_lat / COORDINATE_PRECISION << "," + << rect.max_lon / COORDINATE_PRECISION; + return out; + } + }; + using RectangleT = RectangleInt2D; struct TreeNode @@ -159,7 +343,7 @@ class StaticRTree explicit StaticRTree(std::vector &input_data_vector, const std::string tree_node_filename, const std::string leaf_node_filename, - const std::vector &coordinate_list) + const std::vector &coordinate_list) : m_element_count(input_data_vector.size()), m_leaf_node_filename(leaf_node_filename) { SimpleLogger().Write() << "constructing r-tree of " << m_element_count @@ -1021,7 +1205,7 @@ class StaticRTree inline void InitializeMBRectangle(RectangleT& rectangle, const std::array &objects, const uint32_t element_count, - const std::vector &coordinate_list) + const std::vector &coordinate_list) { for (uint32_t i = 0; i < element_count; ++i) { diff --git a/Server/DataStructures/InternalDataFacade.h b/Server/DataStructures/InternalDataFacade.h index 77432d33d..9f2019e32 100644 --- a/Server/DataStructures/InternalDataFacade.h +++ b/Server/DataStructures/InternalDataFacade.h @@ -126,14 +126,14 @@ template class InternalDataFacade : public BaseDataFacade>(number_of_coordinates); for (unsigned i = 0; i < number_of_coordinates; ++i) { - nodes_input_stream.read((char *)¤t_node, sizeof(NodeInfo)); + nodes_input_stream.read((char *)¤t_node, sizeof(QueryNode)); m_coordinate_list->at(i) = FixedPointCoordinate(current_node.lat, current_node.lon); BOOST_ASSERT((std::abs(m_coordinate_list->at(i).lat) >> 30) == 0); BOOST_ASSERT((std::abs(m_coordinate_list->at(i).lon) >> 30) == 0); diff --git a/Tools/components.cpp b/Tools/components.cpp index b60077bd0..b2b59a31f 100644 --- a/Tools/components.cpp +++ b/Tools/components.cpp @@ -37,7 +37,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -std::vector coordinate_list; +std::vector coordinate_list; std::vector restrictions_vector; std::vector bollard_ID_list; std::vector trafficlight_ID_list; diff --git a/Util/FingerPrint.h b/Util/FingerPrint.h index c61fe360e..5fd04b60e 100644 --- a/Util/FingerPrint.h +++ b/Util/FingerPrint.h @@ -42,7 +42,6 @@ class FingerPrint bool TestGraphUtil(const FingerPrint &other) const; bool TestPrepare(const FingerPrint &other) const; bool TestRTree(const FingerPrint &other) const; - bool TestNodeInfo(const FingerPrint &other) const; bool TestQueryObjects(const FingerPrint &other) const; private: diff --git a/Util/GraphLoader.h b/Util/GraphLoader.h index a7eab64f0..44c466cc9 100644 --- a/Util/GraphLoader.h +++ b/Util/GraphLoader.h @@ -57,7 +57,7 @@ NodeID readBinaryOSRMGraphFromStream(std::istream &input_stream, std::vector &edge_list, std::vector &barrier_node_list, std::vector &traffic_light_node_list, - std::vector *int_to_ext_node_id_map, + std::vector *int_to_ext_node_id_map, std::vector &restriction_list) { const FingerPrint fingerprint_orig; diff --git a/datastore.cpp b/datastore.cpp index e26ab4b8a..7a376b4ff 100644 --- a/datastore.cpp +++ b/datastore.cpp @@ -481,10 +481,10 @@ int main(const int argc, const char *argv[]) shared_layout_ptr->GetBlockPtr( shared_memory_ptr, SharedDataLayout::COORDINATE_LIST); - NodeInfo current_node; + QueryNode current_node; for (unsigned i = 0; i < coordinate_list_size; ++i) { - nodes_input_stream.read((char *)¤t_node, sizeof(NodeInfo)); + nodes_input_stream.read((char *)¤t_node, sizeof(QueryNode)); coordinates_ptr[i] = FixedPointCoordinate(current_node.lat, current_node.lon); } nodes_input_stream.close(); From 51219832180c7ceeb7b3fc4fefeeacdb8ce1d5d5 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Fri, 29 Aug 2014 12:37:18 +0200 Subject: [PATCH 57/80] Rename NodeInfo -> QueryNode --- UnitTests/DataStructures/StaticRTreeTest.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/UnitTests/DataStructures/StaticRTreeTest.cpp b/UnitTests/DataStructures/StaticRTreeTest.cpp index 63a9d3af5..88e62cfa3 100644 --- a/UnitTests/DataStructures/StaticRTreeTest.cpp +++ b/UnitTests/DataStructures/StaticRTreeTest.cpp @@ -181,7 +181,7 @@ template struct RandomGraphFixture { int lat = lat_udist(g); int lon = lon_udist(g); - nodes.emplace_back(NodeInfo(lat, lon, i)); + nodes.emplace_back(QueryNode(lat, lon, i)); coords->emplace_back(FixedPointCoordinate(lat, lon)); } @@ -204,7 +204,7 @@ template struct RandomGraphFixture } } - std::vector nodes; + std::vector nodes; std::shared_ptr> coords; std::vector edges; }; @@ -221,7 +221,7 @@ struct GraphFixture FixedPointCoordinate c(input_coords[i].first * COORDINATE_PRECISION, input_coords[i].second * COORDINATE_PRECISION); coords->emplace_back(c); - nodes.emplace_back(NodeInfo(c.lat, c.lon, i)); + nodes.emplace_back(QueryNode(c.lat, c.lon, i)); } for (const auto &pair : input_edges) @@ -233,7 +233,7 @@ struct GraphFixture } } - std::vector nodes; + std::vector nodes; std::shared_ptr> coords; std::vector edges; }; @@ -316,7 +316,7 @@ void build_rtree(const std::string &prefix, boost::filesystem::ofstream node_stream(coords_path, std::ios::binary); const unsigned num_nodes = fixture->nodes.size(); node_stream.write((char *)&num_nodes, sizeof(unsigned)); - node_stream.write((char *)&(fixture->nodes[0]), num_nodes * sizeof(NodeInfo)); + node_stream.write((char *)&(fixture->nodes[0]), num_nodes * sizeof(QueryNode)); node_stream.close(); RTreeT r(fixture->edges, nodes_path, leaves_path, fixture->nodes); From 59f1679d37edeb653359b6eec293df15d67299b1 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Fri, 29 Aug 2014 12:46:23 +0200 Subject: [PATCH 58/80] move LUA error callback function into anonymous namespace --- Extractor/Extractor.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Extractor/Extractor.cpp b/Extractor/Extractor.cpp index a8423e5a6..32d59aa84 100644 --- a/Extractor/Extractor.cpp +++ b/Extractor/Extractor.cpp @@ -62,6 +62,7 @@ Extractor::Extractor() : requested_num_threads(0), file_has_pbf_format(false) { } +namespace { int lua_error_callback(lua_State *L) // This is so I can use my own function as an // exception handler, pcall_log() { @@ -70,6 +71,7 @@ int lua_error_callback(lua_State *L) // This is so I can use my own function as error_stream << error_msg; throw OSRMException("ERROR occured in profile script:\n" + error_stream.str()); } +} bool Extractor::ParseArguments(int argc, char *argv[]) { From ea1a89290a71886a5ba9918df5ed58009d53a2d7 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Fri, 29 Aug 2014 15:45:12 +0200 Subject: [PATCH 59/80] uncouple configuration of Extractor into compile unit --- Extractor/Extractor.cpp | 220 +++++++-------------------------- Extractor/Extractor.h | 28 +---- Extractor/ExtractorOptions.cpp | 167 +++++++++++++++++++++++++ Extractor/ExtractorOptions.h | 53 ++++++++ 4 files changed, 264 insertions(+), 204 deletions(-) create mode 100644 Extractor/ExtractorOptions.cpp create mode 100644 Extractor/ExtractorOptions.h diff --git a/Extractor/Extractor.cpp b/Extractor/Extractor.cpp index 32d59aa84..00e2e615d 100644 --- a/Extractor/Extractor.cpp +++ b/Extractor/Extractor.cpp @@ -31,6 +31,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "ExtractionNode.h" #include "ExtractionWay.h" #include "ExtractorCallbacks.h" +#include "ExtractorOptions.h" #include "RestrictionParser.h" #include "ScriptingEnvironment.h" @@ -42,14 +43,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "../Util/make_unique.hpp" #include "../typedefs.h" -#include - #include -#include - #include +#include + #include #include @@ -58,11 +57,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -Extractor::Extractor() : requested_num_threads(0), file_has_pbf_format(false) +namespace { -} - -namespace { int lua_error_callback(lua_State *L) // This is so I can use my own function as an // exception handler, pcall_log() { @@ -73,199 +69,66 @@ int lua_error_callback(lua_State *L) // This is so I can use my own function as } } -bool Extractor::ParseArguments(int argc, char *argv[]) -{ - // declare a group of options that will be allowed only on command line - boost::program_options::options_description generic_options("Options"); - generic_options.add_options()("version,v", "Show version")("help,h", "Show this help message")( - "config,c", - boost::program_options::value(&config_file_path) - ->default_value("extractor.ini"), - "Path to a configuration file."); - - // declare a group of options that will be allowed both on command line and in config file - boost::program_options::options_description config_options("Configuration"); - config_options.add_options()("profile,p", - boost::program_options::value( - &profile_path)->default_value("profile.lua"), - "Path to LUA routing profile")( - "threads,t", - boost::program_options::value(&requested_num_threads) - ->default_value(tbb::task_scheduler_init::default_num_threads()), - "Number of threads to use"); - - // hidden options, will be allowed both on command line and in config file, but will not be - // shown to the user - boost::program_options::options_description hidden_options("Hidden options"); - hidden_options.add_options()( - "input,i", - boost::program_options::value(&input_path), - "Input file in .osm, .osm.bz2 or .osm.pbf format"); - - // positional option - boost::program_options::positional_options_description positional_options; - positional_options.add("input", 1); - - // combine above options for parsing - boost::program_options::options_description cmdline_options; - cmdline_options.add(generic_options).add(config_options).add(hidden_options); - - boost::program_options::options_description config_file_options; - config_file_options.add(config_options).add(hidden_options); - - boost::program_options::options_description visible_options( - boost::filesystem::basename(argv[0]) + " [options]"); - visible_options.add(generic_options).add(config_options); - - // parse command line options - boost::program_options::variables_map option_variables; - boost::program_options::store(boost::program_options::command_line_parser(argc, argv) - .options(cmdline_options) - .positional(positional_options) - .run(), - option_variables); - - if (option_variables.count("version")) - { - SimpleLogger().Write() << g_GIT_DESCRIPTION; - return false; - } - - if (option_variables.count("help")) - { - SimpleLogger().Write() << visible_options; - return false; - } - - boost::program_options::notify(option_variables); - - // parse config file - if (boost::filesystem::is_regular_file(config_file_path)) - { - SimpleLogger().Write() << "Reading options from: " << config_file_path.string(); - std::string ini_file_contents = ReadIniFileAndLowerContents(config_file_path); - std::stringstream config_stream(ini_file_contents); - boost::program_options::store(parse_config_file(config_stream, config_file_options), - option_variables); - boost::program_options::notify(option_variables); - } - - if (!option_variables.count("input")) - { - SimpleLogger().Write() << visible_options; - return false; - } - - return true; -} - -void Extractor::GenerateOutputFilesNames() -{ - output_file_name = input_path.string(); - restriction_file_name = input_path.string(); - timestamp_file_name = input_path.string(); - std::string::size_type pos = output_file_name.find(".osm.bz2"); - if (pos == std::string::npos) - { - pos = output_file_name.find(".osm.pbf"); - if (pos != std::string::npos) - { - file_has_pbf_format = true; - } - else - { - pos = output_file_name.find(".osm.xml"); - } - } - if (pos == std::string::npos) - { - pos = output_file_name.find(".pbf"); - if (pos != std::string::npos) - { - file_has_pbf_format = true; - } - } - if (pos == std::string::npos) - { - pos = output_file_name.find(".osm"); - if (pos == std::string::npos) - { - output_file_name.append(".osrm"); - restriction_file_name.append(".osrm.restrictions"); - timestamp_file_name.append(".osrm.timestamp"); - } - else - { - output_file_name.replace(pos, 5, ".osrm"); - restriction_file_name.replace(pos, 5, ".osrm.restrictions"); - timestamp_file_name.replace(pos, 5, ".osrm.timestamp"); - } - } - else - { - output_file_name.replace(pos, 8, ".osrm"); - restriction_file_name.replace(pos, 8, ".osrm.restrictions"); - timestamp_file_name.replace(pos, 8, ".osrm.timestamp"); - } -} - int Extractor::Run(int argc, char *argv[]) { + ExtractorConfig extractor_config; + try { LogPolicy::GetInstance().Unmute(); - TIMER_START(extracting); - if (!ParseArguments(argc, argv)) + if (!ExtractorOptions::ParseArguments(argc, argv, extractor_config)) + { return 0; + } + ExtractorOptions::GenerateOutputFilesNames(extractor_config); - if (1 > requested_num_threads) + if (1 > extractor_config.requested_num_threads) { SimpleLogger().Write(logWARNING) << "Number of threads must be 1 or larger"; return 1; } - if (!boost::filesystem::is_regular_file(input_path)) + if (!boost::filesystem::is_regular_file(extractor_config.input_path)) { - SimpleLogger().Write(logWARNING) << "Input file " << input_path.string() - << " not found!"; + SimpleLogger().Write(logWARNING) + << "Input file " << extractor_config.input_path.string() << " not found!"; return 1; } - if (!boost::filesystem::is_regular_file(profile_path)) + if (!boost::filesystem::is_regular_file(extractor_config.profile_path)) { - SimpleLogger().Write(logWARNING) << "Profile " << profile_path.string() + SimpleLogger().Write(logWARNING) << "Profile " << extractor_config.profile_path.string() << " not found!"; return 1; } const unsigned recommended_num_threads = tbb::task_scheduler_init::default_num_threads(); - SimpleLogger().Write() << "Input file: " << input_path.filename().string(); - SimpleLogger().Write() << "Profile: " << profile_path.filename().string(); - SimpleLogger().Write() << "Threads: " << requested_num_threads; - if (recommended_num_threads != requested_num_threads) + SimpleLogger().Write() << "Input file: " << extractor_config.input_path.filename().string(); + SimpleLogger().Write() << "Profile: " << extractor_config.profile_path.filename().string(); + SimpleLogger().Write() << "Threads: " << extractor_config.requested_num_threads; + if (recommended_num_threads != extractor_config.requested_num_threads) { SimpleLogger().Write(logWARNING) << "The recommended number of threads is " << recommended_num_threads << "! This setting may have performance side-effects."; } - tbb::task_scheduler_init init(requested_num_threads); + tbb::task_scheduler_init init(extractor_config.requested_num_threads); /*** Setup Scripting Environment ***/ - ScriptingEnvironment scripting_environment(profile_path.string().c_str()); - - GenerateOutputFilesNames(); + ScriptingEnvironment scripting_environment(extractor_config.profile_path.string().c_str()); std::unordered_map string_map; ExtractionContainers extraction_containers; string_map[""] = 0; - auto extractor_callbacks = osrm::make_unique(extraction_containers, string_map); + auto extractor_callbacks = + osrm::make_unique(extraction_containers, string_map); - osmium::io::File infile(input_path.string()); + osmium::io::File infile(extractor_config.input_path.string()); osmium::io::Reader reader(infile); osmium::io::Header header = reader.header(); @@ -292,7 +155,7 @@ int Extractor::Run(int argc, char *argv[]) } SimpleLogger().Write() << "timestamp: " << timestamp; - boost::filesystem::ofstream timestamp_out(timestamp_file_name); + boost::filesystem::ofstream timestamp_out(extractor_config.timestamp_file_name); timestamp_out.write(timestamp.c_str(), timestamp.length()); timestamp_out.close(); @@ -313,24 +176,21 @@ int Extractor::Run(int argc, char *argv[]) case osmium::item_type::node: ++number_of_nodes; result_node.Clear(); - luabind::call_function( - lua_state, - "node_function", - boost::cref(static_cast(entity)), - boost::ref(result_node)); + luabind::call_function(lua_state, + "node_function", + boost::cref(static_cast(entity)), + boost::ref(result_node)); extractor_callbacks->ProcessNode(static_cast(entity), result_node); break; case osmium::item_type::way: ++number_of_ways; result_way.Clear(); - luabind::call_function( - lua_state, - "way_function", - boost::cref(static_cast(entity)), - boost::ref(result_way)); - extractor_callbacks->ProcessWay(static_cast(entity), - result_way); + luabind::call_function(lua_state, + "way_function", + boost::cref(static_cast(entity)), + boost::ref(result_way)); + extractor_callbacks->ProcessWay(static_cast(entity), result_way); break; case osmium::item_type::relation: ++number_of_relations; @@ -345,7 +205,9 @@ int Extractor::Run(int argc, char *argv[]) } TIMER_STOP(parsing); SimpleLogger().Write() << "Parsing finished after " << TIMER_SEC(parsing) << " seconds"; - SimpleLogger().Write() << "Raw input contains " << number_of_nodes << " nodes, " << number_of_ways << " ways, and " << number_of_relations << " relations"; + SimpleLogger().Write() << "Raw input contains " << number_of_nodes << " nodes, " + << number_of_ways << " ways, and " << number_of_relations + << " relations"; extractor_callbacks.reset(); @@ -355,12 +217,14 @@ int Extractor::Run(int argc, char *argv[]) return 1; } - extraction_containers.PrepareData(output_file_name, restriction_file_name); + extraction_containers.PrepareData(extractor_config.output_file_name, + extractor_config.restriction_file_name); TIMER_STOP(extracting); SimpleLogger().Write() << "extraction finished after " << TIMER_SEC(extracting) << "s"; SimpleLogger().Write() << "To prepare the data for routing, run: " - << "./osrm-prepare " << output_file_name << std::endl; + << "./osrm-prepare " << extractor_config.output_file_name + << std::endl; } catch (boost::program_options::too_many_positional_options_error &) { diff --git a/Extractor/Extractor.h b/Extractor/Extractor.h index 355c5be90..3f98b9776 100644 --- a/Extractor/Extractor.h +++ b/Extractor/Extractor.h @@ -1,37 +1,13 @@ #ifndef EXTRACTOR_H_ #define EXTRACTOR_H_ -#include - #include -class ExtractorCallbacks; +#include /** \brief Class of 'extract' utility. */ -class Extractor +struct Extractor { - protected: - unsigned requested_num_threads; - boost::filesystem::path config_file_path; - boost::filesystem::path input_path; - boost::filesystem::path profile_path; - - std::string output_file_name; - std::string restriction_file_name; - std::string timestamp_file_name; - bool file_has_pbf_format; - - /** \brief Parses "extractor's" command line arguments */ - bool ParseArguments(int argc, char *argv[]); - - /** \brief Parses config file, if present in options */ - void GenerateOutputFilesNames(); - - public: - explicit Extractor(); - Extractor(const Extractor &) = delete; - virtual ~Extractor() = default; - int Run(int argc, char *argv[]); }; #endif /* EXTRACTOR_H_ */ diff --git a/Extractor/ExtractorOptions.cpp b/Extractor/ExtractorOptions.cpp new file mode 100644 index 000000000..7c9575b95 --- /dev/null +++ b/Extractor/ExtractorOptions.cpp @@ -0,0 +1,167 @@ +/* + +Copyright (c) 2013, Project OSRM, Dennis Luxen, others +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +*/ + +#include "ExtractorOptions.h" + +#include "../Util/GitDescription.h" +#include "../Util/IniFileUtil.h" +#include "../Util/SimpleLogger.h" + +#include +#include + +#include + +bool ExtractorOptions::ParseArguments(int argc, char *argv[], ExtractorConfig &extractor_config) +{ + // declare a group of options that will be allowed only on command line + boost::program_options::options_description generic_options("Options"); + generic_options.add_options()("version,v", "Show version")("help,h", "Show this help message")( + "config,c", + boost::program_options::value(&extractor_config.config_file_path) + ->default_value("extractor.ini"), + "Path to a configuration file."); + + // declare a group of options that will be allowed both on command line and in config file + boost::program_options::options_description config_options("Configuration"); + config_options.add_options()("profile,p", + boost::program_options::value( + &extractor_config.profile_path)->default_value("profile.lua"), + "Path to LUA routing profile")( + "threads,t", + boost::program_options::value(&extractor_config.requested_num_threads) + ->default_value(tbb::task_scheduler_init::default_num_threads()), + "Number of threads to use"); + + // hidden options, will be allowed both on command line and in config file, but will not be + // shown to the user + boost::program_options::options_description hidden_options("Hidden options"); + hidden_options.add_options()( + "input,i", + boost::program_options::value(&extractor_config.input_path), + "Input file in .osm, .osm.bz2 or .osm.pbf format"); + + // positional option + boost::program_options::positional_options_description positional_options; + positional_options.add("input", 1); + + // combine above options for parsing + boost::program_options::options_description cmdline_options; + cmdline_options.add(generic_options).add(config_options).add(hidden_options); + + boost::program_options::options_description config_file_options; + config_file_options.add(config_options).add(hidden_options); + + boost::program_options::options_description visible_options( + boost::filesystem::basename(argv[0]) + " [options]"); + visible_options.add(generic_options).add(config_options); + + // parse command line options + boost::program_options::variables_map option_variables; + boost::program_options::store(boost::program_options::command_line_parser(argc, argv) + .options(cmdline_options) + .positional(positional_options) + .run(), + option_variables); + + if (option_variables.count("version")) + { + SimpleLogger().Write() << g_GIT_DESCRIPTION; + return false; + } + + if (option_variables.count("help")) + { + SimpleLogger().Write() << visible_options; + return false; + } + + boost::program_options::notify(option_variables); + + // parse config file + if (boost::filesystem::is_regular_file(extractor_config.config_file_path)) + { + SimpleLogger().Write() << "Reading options from: " + << extractor_config.config_file_path.string(); + std::string ini_file_contents = + ReadIniFileAndLowerContents(extractor_config.config_file_path); + std::stringstream config_stream(ini_file_contents); + boost::program_options::store(parse_config_file(config_stream, config_file_options), + option_variables); + boost::program_options::notify(option_variables); + } + + if (!option_variables.count("input")) + { + SimpleLogger().Write() << visible_options; + return false; + } + return true; +} + +void ExtractorOptions::GenerateOutputFilesNames(ExtractorConfig &extractor_config) +{ + boost::filesystem::path &input_path = extractor_config.input_path; + extractor_config.output_file_name = input_path.string(); + extractor_config.restriction_file_name = input_path.string(); + extractor_config.timestamp_file_name = input_path.string(); + std::string::size_type pos = extractor_config.output_file_name.find(".osm.bz2"); + if (pos == std::string::npos) + { + pos = extractor_config.output_file_name.find(".osm.pbf"); + if (pos == std::string::npos) + { + pos = extractor_config.output_file_name.find(".osm.xml"); + } + } + if (pos == std::string::npos) + { + pos = extractor_config.output_file_name.find(".pbf"); + } + if (pos == std::string::npos) + { + pos = extractor_config.output_file_name.find(".osm"); + if (pos == std::string::npos) + { + extractor_config.output_file_name.append(".osrm"); + extractor_config.restriction_file_name.append(".osrm.restrictions"); + extractor_config.timestamp_file_name.append(".osrm.timestamp"); + } + else + { + extractor_config.output_file_name.replace(pos, 5, ".osrm"); + extractor_config.restriction_file_name.replace(pos, 5, ".osrm.restrictions"); + extractor_config.timestamp_file_name.replace(pos, 5, ".osrm.timestamp"); + } + } + else + { + extractor_config.output_file_name.replace(pos, 8, ".osrm"); + extractor_config.restriction_file_name.replace(pos, 8, ".osrm.restrictions"); + extractor_config.timestamp_file_name.replace(pos, 8, ".osrm.timestamp"); + } +} diff --git a/Extractor/ExtractorOptions.h b/Extractor/ExtractorOptions.h new file mode 100644 index 000000000..60d93c7b7 --- /dev/null +++ b/Extractor/ExtractorOptions.h @@ -0,0 +1,53 @@ +/* + +Copyright (c) 2013, Project OSRM, Dennis Luxen, others +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +*/ + +#ifndef EXTRACTOR_OPTIONS_H__ +#define EXTRACTOR_OPTIONS_H__ + +#include "Extractor.h" + +struct ExtractorConfig +{ + ExtractorConfig() noexcept : requested_num_threads(0) {} + unsigned requested_num_threads; + boost::filesystem::path config_file_path; + boost::filesystem::path input_path; + boost::filesystem::path profile_path; + + std::string output_file_name; + std::string restriction_file_name; + std::string timestamp_file_name; +}; + +struct ExtractorOptions +{ + static bool ParseArguments(int argc, char *argv[], ExtractorConfig &extractor_config); + + static void GenerateOutputFilesNames(ExtractorConfig &extractor_config); +}; + +#endif // EXTRACTOR_OPTIONS_H__ From 0d9b70552eaa8efced6b45936d56e9496507ff8f Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Mon, 1 Sep 2014 10:26:45 +0200 Subject: [PATCH 60/80] refactor FirstAndLastSegmentOfWay --- Extractor/ExtractionContainers.cpp | 42 +++++++++++++------------- Extractor/FirstAndLastSegmentOfWay.h | 44 +++++++++++++++------------- 2 files changed, 45 insertions(+), 41 deletions(-) diff --git a/Extractor/ExtractionContainers.cpp b/Extractor/ExtractionContainers.cpp index 55e971cb0..204ab79c2 100644 --- a/Extractor/ExtractionContainers.cpp +++ b/Extractor/ExtractionContainers.cpp @@ -119,39 +119,39 @@ void ExtractionContainers::PrepareData(const std::string &output_file_name, while (way_start_and_end_iterator != way_start_end_id_list.end() && restrictions_iterator != restrictions_list.end()) { - if (way_start_and_end_iterator->wayID < restrictions_iterator->restriction.from.way) + if (way_start_and_end_iterator->way_id < restrictions_iterator->restriction.from.way) { ++way_start_and_end_iterator; continue; } - if (way_start_and_end_iterator->wayID > restrictions_iterator->restriction.from.way) + if (way_start_and_end_iterator->way_id > restrictions_iterator->restriction.from.way) { ++restrictions_iterator; continue; } - BOOST_ASSERT(way_start_and_end_iterator->wayID == restrictions_iterator->restriction.from.way); + BOOST_ASSERT(way_start_and_end_iterator->way_id == restrictions_iterator->restriction.from.way); const NodeID via_node_id = restrictions_iterator->restriction.via.node; - if (way_start_and_end_iterator->firstStart == via_node_id) + if (way_start_and_end_iterator->first_segment_source_id == via_node_id) { restrictions_iterator->restriction.from.node = - way_start_and_end_iterator->firstTarget; + way_start_and_end_iterator->first_segment_source_id; } - else if (way_start_and_end_iterator->firstTarget == via_node_id) + else if (way_start_and_end_iterator->first_segment_source_id == via_node_id) { restrictions_iterator->restriction.from.node = - way_start_and_end_iterator->firstStart; + way_start_and_end_iterator->first_segment_source_id; } - else if (way_start_and_end_iterator->lastStart == via_node_id) + else if (way_start_and_end_iterator->last_segment_source_id == via_node_id) { restrictions_iterator->restriction.from.node = - way_start_and_end_iterator->lastTarget; + way_start_and_end_iterator->last_segment_target_id; } - else if (way_start_and_end_iterator->lastTarget == via_node_id) + else if (way_start_and_end_iterator->last_segment_target_id == via_node_id) { - restrictions_iterator->restriction.from.node = way_start_and_end_iterator->lastStart; + restrictions_iterator->restriction.from.node = way_start_and_end_iterator->last_segment_source_id; } ++restrictions_iterator; } @@ -176,32 +176,32 @@ void ExtractionContainers::PrepareData(const std::string &output_file_name, while (way_start_and_end_iterator != way_start_end_id_list.end() && restrictions_iterator != restrictions_list.end()) { - if (way_start_and_end_iterator->wayID < restrictions_iterator->restriction.to.way) + if (way_start_and_end_iterator->way_id < restrictions_iterator->restriction.to.way) { ++way_start_and_end_iterator; continue; } - if (way_start_and_end_iterator->wayID > restrictions_iterator->restriction.to.way) + if (way_start_and_end_iterator->way_id > restrictions_iterator->restriction.to.way) { ++restrictions_iterator; continue; } NodeID via_node_id = restrictions_iterator->restriction.via.node; - if (way_start_and_end_iterator->lastStart == via_node_id) + if (way_start_and_end_iterator->last_segment_source_id == via_node_id) { - restrictions_iterator->restriction.to.node = way_start_and_end_iterator->lastTarget; + restrictions_iterator->restriction.to.node = way_start_and_end_iterator->last_segment_target_id; } - else if (way_start_and_end_iterator->lastTarget == via_node_id) + else if (way_start_and_end_iterator->last_segment_target_id == via_node_id) { - restrictions_iterator->restriction.to.node = way_start_and_end_iterator->lastStart; + restrictions_iterator->restriction.to.node = way_start_and_end_iterator->last_segment_source_id; } - else if (way_start_and_end_iterator->firstStart == via_node_id) + else if (way_start_and_end_iterator->first_segment_source_id == via_node_id) { - restrictions_iterator->restriction.to.node = way_start_and_end_iterator->firstTarget; + restrictions_iterator->restriction.to.node = way_start_and_end_iterator->first_segment_source_id; } - else if (way_start_and_end_iterator->firstTarget == via_node_id) + else if (way_start_and_end_iterator->first_segment_source_id == via_node_id) { - restrictions_iterator->restriction.to.node = way_start_and_end_iterator->firstStart; + restrictions_iterator->restriction.to.node = way_start_and_end_iterator->first_segment_source_id; } if (std::numeric_limits::max() != restrictions_iterator->restriction.from.node && diff --git a/Extractor/FirstAndLastSegmentOfWay.h b/Extractor/FirstAndLastSegmentOfWay.h index fb23e48fc..a1be23e08 100644 --- a/Extractor/FirstAndLastSegmentOfWay.h +++ b/Extractor/FirstAndLastSegmentOfWay.h @@ -36,37 +36,41 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. struct FirstAndLastSegmentOfWay { - EdgeID wayID; - NodeID firstStart; - NodeID firstTarget; - NodeID lastStart; - NodeID lastTarget; + EdgeID way_id; + NodeID first_segment_source_id; + NodeID first_segment_target_id; + NodeID last_segment_source_id; + NodeID last_segment_target_id; FirstAndLastSegmentOfWay() - : wayID(std::numeric_limits::max()), firstStart(std::numeric_limits::max()), firstTarget(std::numeric_limits::max()), lastStart(std::numeric_limits::max()), - lastTarget(std::numeric_limits::max()) + : way_id(std::numeric_limits::max()), + first_segment_source_id(std::numeric_limits::max()), + first_segment_target_id(std::numeric_limits::max()), + last_segment_source_id(std::numeric_limits::max()), + last_segment_target_id(std::numeric_limits::max()) { } - FirstAndLastSegmentOfWay(unsigned w, NodeID fs, NodeID ft, NodeID ls, NodeID lt) - : wayID(w), firstStart(fs), firstTarget(ft), lastStart(ls), lastTarget(lt) + FirstAndLastSegmentOfWay(EdgeID w, NodeID fs, NodeID ft, NodeID ls, NodeID lt) + : way_id(w), first_segment_source_id(fs), first_segment_target_id(ft), + last_segment_source_id(ls), last_segment_target_id(lt) { } static FirstAndLastSegmentOfWay min_value() { - return FirstAndLastSegmentOfWay((std::numeric_limits::min)(), - (std::numeric_limits::min)(), - (std::numeric_limits::min)(), - (std::numeric_limits::min)(), - (std::numeric_limits::min)()); + return {std::numeric_limits::min(), + std::numeric_limits::min(), + std::numeric_limits::min(), + std::numeric_limits::min(), + std::numeric_limits::min()}; } static FirstAndLastSegmentOfWay max_value() { - return FirstAndLastSegmentOfWay((std::numeric_limits::max)(), - (std::numeric_limits::max)(), - (std::numeric_limits::max)(), - (std::numeric_limits::max)(), - (std::numeric_limits::max)()); + return {std::numeric_limits::max(), + std::numeric_limits::max(), + std::numeric_limits::max(), + std::numeric_limits::max(), + std::numeric_limits::max()}; } }; @@ -75,7 +79,7 @@ struct FirstAndLastSegmentOfWayStxxlCompare using value_type = FirstAndLastSegmentOfWay; bool operator()(const FirstAndLastSegmentOfWay &a, const FirstAndLastSegmentOfWay &b) const { - return a.wayID < b.wayID; + return a.way_id < b.way_id; } value_type max_value() { return FirstAndLastSegmentOfWay::max_value(); } value_type min_value() { return FirstAndLastSegmentOfWay::min_value(); } From b131f27eb9b1d927afaa7cc86bbb83c3a4978e00 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Mon, 22 Sep 2014 11:41:05 +0200 Subject: [PATCH 61/80] use_turn_restrictions as global in car profile --- profiles/car.lua | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/profiles/car.lua b/profiles/car.lua index 0a0c01652..58addb046 100644 --- a/profiles/car.lua +++ b/profiles/car.lua @@ -124,11 +124,11 @@ maxspeed_table = { } traffic_signal_penalty = 2 +use_turn_restrictions = true local take_minimum_of_speeds = false local obey_oneway = true local obey_bollards = true -local use_turn_restrictions = true local ignore_areas = true -- future feature local u_turn_penalty = 20 From a0256dfc60a94786ba3dc1d8215fea38cf2c3d2c Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Mon, 22 Sep 2014 11:42:52 +0200 Subject: [PATCH 62/80] add error callback when calling get_exceptions --- Extractor/RestrictionParser.cpp | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/Extractor/RestrictionParser.cpp b/Extractor/RestrictionParser.cpp index 6fc5ca979..5001bdfbc 100644 --- a/Extractor/RestrictionParser.cpp +++ b/Extractor/RestrictionParser.cpp @@ -41,11 +41,25 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include +namespace { +int lua_error_callback(lua_State *L) +{ + luabind::object error_msg(luabind::from_stack(L, -1)); + std::ostringstream error_stream; + error_stream << error_msg; + throw OSRMException("ERROR occured in profile script:\n" + error_stream.str()); +} +} + RestrictionParser::RestrictionParser(ScriptingEnvironment &scripting_environment) : lua_state(scripting_environment.getLuaState()), use_turn_restrictions(true) { ReadUseRestrictionsSetting(); - ReadRestrictionExceptions(); + + if (use_turn_restrictions) + { + ReadRestrictionExceptions(); + } } void RestrictionParser::ReadUseRestrictionsSetting() @@ -72,6 +86,7 @@ void RestrictionParser::ReadRestrictionExceptions() { if (lua_function_exists(lua_state, "get_exceptions")) { + luabind::set_pcall_callback(&lua_error_callback); // get list of turn restriction exceptions luabind::call_function( lua_state, "get_exceptions", boost::ref(restriction_exceptions)); From 344bdbb70714b8ee424adbb03ae85dc86d07ff0d Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Tue, 23 Sep 2014 09:36:53 +0200 Subject: [PATCH 63/80] basic parallelization infrastructure --- Extractor/ExtractionWay.h | 2 + Extractor/Extractor.cpp | 122 ++++++++++++++++++++++++++++--- Extractor/ExtractorCallbacks.cpp | 64 ++++++++-------- Extractor/ExtractorCallbacks.h | 4 +- 4 files changed, 148 insertions(+), 44 deletions(-) diff --git a/Extractor/ExtractionWay.h b/Extractor/ExtractionWay.h index 740c4beaf..d42595a7b 100644 --- a/Extractor/ExtractionWay.h +++ b/Extractor/ExtractionWay.h @@ -40,6 +40,7 @@ struct ExtractionWay void Clear() { + id = -1; forward_speed = -1; backward_speed = -1; duration = -1; @@ -106,6 +107,7 @@ struct ExtractionWay void set_backward_mode(const TravelMode m) { backward_travel_mode = m; } const TravelMode get_backward_mode() const { return backward_travel_mode; } + int64_t id; double forward_speed; double backward_speed; double duration; diff --git a/Extractor/Extractor.cpp b/Extractor/Extractor.cpp index 00e2e615d..c442ad325 100644 --- a/Extractor/Extractor.cpp +++ b/Extractor/Extractor.cpp @@ -37,10 +37,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "../Util/GitDescription.h" #include "../Util/IniFileUtil.h" +#include "../DataStructures/ConcurrentQueue.h" #include "../Util/OSRMException.h" #include "../Util/simple_logger.hpp" #include "../Util/TimingUtil.h" #include "../Util/make_unique.hpp" + #include "../typedefs.h" #include @@ -49,16 +51,28 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include +#include + #include +#include #include #include #include #include #include +#include namespace { + +struct ResultBuffer +{ + std::vector> nodes; + std::vector> ways; + std::vector> restrictions; +}; + int lua_error_callback(lua_State *L) // This is so I can use my own function as an // exception handler, pcall_log() { @@ -147,7 +161,7 @@ int Extractor::Run(int argc, char *argv[]) } SimpleLogger().Write() << "input file generated by " << generator; - // TODO: write timestamp if non-empty + // write .timestamp data file std::string timestamp = header.get("osmosis_replication_timestamp"); if (timestamp.empty()) { @@ -164,12 +178,35 @@ int Extractor::Run(int argc, char *argv[]) RestrictionParser restriction_parser(scripting_environment); - ExtractionNode result_node; - ExtractionWay result_way; + // move to header + std::atomic_bool parsing_done {false}; + std::atomic_bool loading_done {false}; - while (osmium::memory::Buffer buffer = reader.read()) + ConcurrentQueue> parse_queue(128); + ConcurrentQueue> result_queue(128); + + std::thread loading_thread([&]{ + while (osmium::memory::Buffer buffer = reader.read()) + { + parse_queue.push(std::make_shared(std::move(buffer))); + } + loading_done = true; + }); + + // parsing threads + while (!loading_done || !parse_queue.empty()) { - for (osmium::OSMEntity &entity : buffer) + std::shared_ptr current_buffer; + if (!parse_queue.try_pop(current_buffer)) + { + continue; + } + + ExtractionNode result_node; + ExtractionWay result_way; + + std::shared_ptr result_buffer = std::make_shared();; + for (osmium::OSMEntity &entity : *current_buffer) { switch (entity.type()) { @@ -180,8 +217,7 @@ int Extractor::Run(int argc, char *argv[]) "node_function", boost::cref(static_cast(entity)), boost::ref(result_node)); - extractor_callbacks->ProcessNode(static_cast(entity), - result_node); + result_buffer->nodes.emplace_back(osmium::NodeRef{static_cast(entity).id(), static_cast(entity).location()}, result_node); break; case osmium::item_type::way: ++number_of_ways; @@ -190,19 +226,85 @@ int Extractor::Run(int argc, char *argv[]) "way_function", boost::cref(static_cast(entity)), boost::ref(result_way)); - extractor_callbacks->ProcessWay(static_cast(entity), result_way); + result_way.id = static_cast(entity).id(); + result_buffer->ways.emplace_back(osmium::WayNodeList{static_cast(entity).nodes()}, result_way); break; case osmium::item_type::relation: ++number_of_relations; - extractor_callbacks->ProcessRestriction( - restriction_parser.TryParse(static_cast(entity))); + result_buffer->restrictions.emplace_back(restriction_parser.TryParse(static_cast(entity))); break; default: ++number_of_others; break; } } + result_queue.push(result_buffer); + parsing_done = true; } + + while (!parsing_done || !result_queue.empty()) + { + std::shared_ptr current_buffer; + if (!result_queue.try_pop(current_buffer)) + { + for (const auto &node : current_buffer->nodes) + { + extractor_callbacks->ProcessNode(node.first, + node.second); + } + for (auto &way : current_buffer->ways) + { + extractor_callbacks->ProcessWay(way.first, + way.second); + } + for (const auto &restriction : current_buffer->restrictions) + { + extractor_callbacks->ProcessRestriction(restriction); + } + + } + } + + loading_thread.join(); + + // TODO: join parser threads + + // while (osmium::memory::Buffer buffer = reader.read()) + // { + // for (osmium::OSMEntity &entity : buffer) + // { + // switch (entity.type()) + // { + // case osmium::item_type::node: + // ++number_of_nodes; + // result_node.Clear(); + // luabind::call_function(lua_state, + // "node_function", + // boost::cref(static_cast(entity)), + // boost::ref(result_node)); + // extractor_callbacks->ProcessNode(static_cast(entity), + // result_node); + // break; + // case osmium::item_type::way: + // ++number_of_ways; + // result_way.Clear(); + // luabind::call_function(lua_state, + // "way_function", + // boost::cref(static_cast(entity)), + // boost::ref(result_way)); + // extractor_callbacks->ProcessWay(static_cast(entity), result_way); + // break; + // case osmium::item_type::relation: + // ++number_of_relations; + // extractor_callbacks->ProcessRestriction( + // restriction_parser.TryParse(static_cast(entity))); + // break; + // default: + // ++number_of_others; + // break; + // } + // } + // } TIMER_STOP(parsing); SimpleLogger().Write() << "Parsing finished after " << TIMER_SEC(parsing) << " seconds"; SimpleLogger().Write() << "Raw input contains " << number_of_nodes << " nodes, " diff --git a/Extractor/ExtractorCallbacks.cpp b/Extractor/ExtractorCallbacks.cpp index 170c4437a..a14f09a2b 100644 --- a/Extractor/ExtractorCallbacks.cpp +++ b/Extractor/ExtractorCallbacks.cpp @@ -48,13 +48,13 @@ ExtractorCallbacks::ExtractorCallbacks(ExtractionContainers &extraction_containe } /** warning: caller needs to take care of synchronization! */ -void ExtractorCallbacks::ProcessNode(const osmium::Node &osm_input_node, +void ExtractorCallbacks::ProcessNode(const osmium::NodeRef &osm_input_node, const ExtractionNode &result_node) { external_memory.all_nodes_list.push_back({ static_cast(osm_input_node.location().lat() * COORDINATE_PRECISION), static_cast(osm_input_node.location().lon() * COORDINATE_PRECISION), - static_cast(osm_input_node.id()), + static_cast(osm_input_node.ref()), result_node.barrier, result_node.traffic_lights }); @@ -69,7 +69,7 @@ void ExtractorCallbacks::ProcessRestriction( } } /** warning: caller needs to take care of synchronization! */ -void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, ExtractionWay &parsed_way) +void ExtractorCallbacks::ProcessWay(const osmium::WayNodeList &input_way, const ExtractionWay &parsed_way) { if (((0 >= parsed_way.forward_speed) || (TRAVEL_MODE_INACCESSIBLE == parsed_way.forward_travel_mode)) && @@ -80,15 +80,15 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, ExtractionWay return; } - if (input_way.nodes().size() <= 1) + if (input_way.size() <= 1) { // safe-guard against broken data return; } - if (std::numeric_limits::max() == input_way.id()) + if (std::numeric_limits::max() == parsed_way.id) { - SimpleLogger().Write(logDEBUG) << "found bogus way with id: " << input_way.id() - << " of size " << input_way.nodes().size(); + SimpleLogger().Write(logDEBUG) << "found bogus way with id: " << parsed_way.id + << " of size " << input_way.size(); return; } @@ -96,13 +96,13 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, ExtractionWay { // TODO: iterate all way segments and set duration corresponding to the length of each // segment - parsed_way.forward_speed = parsed_way.duration / (input_way.nodes().size() - 1); - parsed_way.backward_speed = parsed_way.duration / (input_way.nodes().size() - 1); + const_cast(parsed_way).forward_speed = parsed_way.duration / (input_way.size() - 1); + const_cast(parsed_way).backward_speed = parsed_way.duration / (input_way.size() - 1); } if (std::numeric_limits::epsilon() >= std::abs(-1. - parsed_way.forward_speed)) { - SimpleLogger().Write(logDEBUG) << "found way with bogus speed, id: " << input_way.id(); + SimpleLogger().Write(logDEBUG) << "found way with bogus speed, id: " << parsed_way.id; return; } @@ -151,27 +151,27 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, ExtractionWay const bool is_opposite_way = TRAVEL_MODE_INACCESSIBLE == parsed_way.forward_travel_mode; if (is_opposite_way) { - parsed_way.forward_travel_mode = parsed_way.backward_travel_mode; - parsed_way.backward_travel_mode = TRAVEL_MODE_INACCESSIBLE; + const_cast(parsed_way).forward_travel_mode = parsed_way.backward_travel_mode; + const_cast(parsed_way).backward_travel_mode = TRAVEL_MODE_INACCESSIBLE; osrm::for_each_pair( - input_way.nodes().crbegin(), input_way.nodes().crend(), pair_wise_segment_split); - external_memory.used_node_id_list.push_back(input_way.nodes().front().ref()); + input_way.crbegin(), input_way.crend(), pair_wise_segment_split); + external_memory.used_node_id_list.push_back(input_way.front().ref()); } else { osrm::for_each_pair( - input_way.nodes().cbegin(), input_way.nodes().cend(), pair_wise_segment_split); - external_memory.used_node_id_list.push_back(input_way.nodes().back().ref()); + input_way.cbegin(), input_way.cend(), pair_wise_segment_split); + external_memory.used_node_id_list.push_back(input_way.back().ref()); } // The following information is needed to identify start and end segments of restrictions // The following information is needed to identify start and end segments of restrictions external_memory.way_start_end_id_list.push_back( - {(EdgeID)input_way.id(), - (NodeID)input_way.nodes()[0].ref(), - (NodeID)input_way.nodes()[1].ref(), - (NodeID)input_way.nodes()[input_way.nodes().size() - 2].ref(), - (NodeID)input_way.nodes().back().ref()}); + {(EdgeID)parsed_way.id, + (NodeID)input_way[0].ref(), + (NodeID)input_way[1].ref(), + (NodeID)input_way[input_way.size() - 2].ref(), + (NodeID)input_way.back().ref()}); if (split_edge) { // Only true if the way should be split @@ -198,24 +198,24 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, ExtractionWay if (is_opposite_way) { // SimpleLogger().Write() << "opposite2"; - osrm::for_each_pair(input_way.nodes().crbegin(), - input_way.nodes().crend(), + osrm::for_each_pair(input_way.crbegin(), + input_way.crend(), pair_wise_segment_split_2); - external_memory.used_node_id_list.push_back(input_way.nodes().front().ref()); + external_memory.used_node_id_list.push_back(input_way.front().ref()); } else { - osrm::for_each_pair(input_way.nodes().cbegin(), - input_way.nodes().cend(), + osrm::for_each_pair(input_way.cbegin(), + input_way.cend(), pair_wise_segment_split_2); - external_memory.used_node_id_list.push_back(input_way.nodes().back().ref()); + external_memory.used_node_id_list.push_back(input_way.back().ref()); } external_memory.way_start_end_id_list.push_back( - {(EdgeID)input_way.id(), - (NodeID)input_way.nodes()[1].ref(), - (NodeID)input_way.nodes()[0].ref(), - (NodeID)input_way.nodes().back().ref(), - (NodeID)input_way.nodes()[input_way.nodes().size() - 2].ref()}); + {(EdgeID)parsed_way.id, + (NodeID)input_way[1].ref(), + (NodeID)input_way[0].ref(), + (NodeID)input_way.back().ref(), + (NodeID)input_way[input_way.size() - 2].ref()}); } } diff --git a/Extractor/ExtractorCallbacks.h b/Extractor/ExtractorCallbacks.h index e43b02b52..baf0f7b67 100644 --- a/Extractor/ExtractorCallbacks.h +++ b/Extractor/ExtractorCallbacks.h @@ -56,13 +56,13 @@ class ExtractorCallbacks std::unordered_map &string_map); // warning: caller needs to take care of synchronization! - void ProcessNode(const osmium::Node ¤t_node, const ExtractionNode &result_node); + void ProcessNode(const osmium::NodeRef ¤t_node, const ExtractionNode &result_node); // warning: caller needs to take care of synchronization! void ProcessRestriction(const mapbox::util::optional &restriction); // warning: caller needs to take care of synchronization! - void ProcessWay(const osmium::Way ¤t_way, ExtractionWay &result_way); + void ProcessWay(const osmium::WayNodeList ¤t_way, const ExtractionWay &result_way); }; #endif /* EXTRACTOR_CALLBACKS_H */ From 3c563f7073470be2d8f42e74bf98a257e100a419 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Mon, 13 Oct 2014 13:53:06 +0200 Subject: [PATCH 64/80] rebase branch onto most recent changes from develop branch --- Contractor/EdgeBasedGraphFactory.cpp | 2 +- Contractor/EdgeBasedGraphFactory.h | 2 +- Extractor/Extractor.cpp | 189 +++++++++++++-------------- Extractor/ExtractorCallbacks.cpp | 56 ++++---- Extractor/ExtractorCallbacks.h | 4 +- Extractor/ExtractorOptions.cpp | 2 +- Extractor/RestrictionParser.cpp | 2 +- 7 files changed, 125 insertions(+), 132 deletions(-) diff --git a/Contractor/EdgeBasedGraphFactory.cpp b/Contractor/EdgeBasedGraphFactory.cpp index 07c4883b9..c882a3a60 100644 --- a/Contractor/EdgeBasedGraphFactory.cpp +++ b/Contractor/EdgeBasedGraphFactory.cpp @@ -45,7 +45,7 @@ EdgeBasedGraphFactory::EdgeBasedGraphFactory( std::unique_ptr restriction_map, std::vector &barrier_node_list, std::vector &traffic_light_node_list, - std::vector &node_info_list, + std::vector &node_info_list, SpeedProfileProperties &speed_profile) : speed_profile(speed_profile), m_number_of_edge_based_nodes(std::numeric_limits::max()), diff --git a/Contractor/EdgeBasedGraphFactory.h b/Contractor/EdgeBasedGraphFactory.h index 65aef649d..1893df58c 100644 --- a/Contractor/EdgeBasedGraphFactory.h +++ b/Contractor/EdgeBasedGraphFactory.h @@ -63,7 +63,7 @@ class EdgeBasedGraphFactory std::unique_ptr restricion_map, std::vector &barrier_node_list, std::vector &traffic_light_node_list, - std::vector &m_node_info_list, + std::vector &node_info_list, SpeedProfileProperties &speed_profile); void Run(const std::string &original_edge_data_filename, diff --git a/Extractor/Extractor.cpp b/Extractor/Extractor.cpp index c442ad325..23a10f784 100644 --- a/Extractor/Extractor.cpp +++ b/Extractor/Extractor.cpp @@ -178,100 +178,35 @@ int Extractor::Run(int argc, char *argv[]) RestrictionParser restriction_parser(scripting_environment); - // move to header - std::atomic_bool parsing_done {false}; - std::atomic_bool loading_done {false}; + // // move to header + // std::atomic_bool parsing_done {false}; + // std::atomic_bool loading_done {false}; - ConcurrentQueue> parse_queue(128); - ConcurrentQueue> result_queue(128); + // ConcurrentQueue> parse_queue(128); + // ConcurrentQueue> result_queue(128); - std::thread loading_thread([&]{ - while (osmium::memory::Buffer buffer = reader.read()) - { - parse_queue.push(std::make_shared(std::move(buffer))); - } - loading_done = true; - }); + // std::thread loading_thread([&]{ + // while (osmium::memory::Buffer buffer = reader.read()) + // { + // parse_queue.push(std::make_shared(std::move(buffer))); + // } + // loading_done = true; + // }); - // parsing threads - while (!loading_done || !parse_queue.empty()) - { - std::shared_ptr current_buffer; - if (!parse_queue.try_pop(current_buffer)) - { - continue; - } + // // parsing threads + // while (!loading_done || !parse_queue.empty()) + // { + // std::shared_ptr current_buffer; + // if (!parse_queue.try_pop(current_buffer)) + // { + // continue; + // } ExtractionNode result_node; ExtractionWay result_way; - std::shared_ptr result_buffer = std::make_shared();; - for (osmium::OSMEntity &entity : *current_buffer) - { - switch (entity.type()) - { - case osmium::item_type::node: - ++number_of_nodes; - result_node.Clear(); - luabind::call_function(lua_state, - "node_function", - boost::cref(static_cast(entity)), - boost::ref(result_node)); - result_buffer->nodes.emplace_back(osmium::NodeRef{static_cast(entity).id(), static_cast(entity).location()}, result_node); - break; - case osmium::item_type::way: - ++number_of_ways; - result_way.Clear(); - luabind::call_function(lua_state, - "way_function", - boost::cref(static_cast(entity)), - boost::ref(result_way)); - result_way.id = static_cast(entity).id(); - result_buffer->ways.emplace_back(osmium::WayNodeList{static_cast(entity).nodes()}, result_way); - break; - case osmium::item_type::relation: - ++number_of_relations; - result_buffer->restrictions.emplace_back(restriction_parser.TryParse(static_cast(entity))); - break; - default: - ++number_of_others; - break; - } - } - result_queue.push(result_buffer); - parsing_done = true; - } - - while (!parsing_done || !result_queue.empty()) - { - std::shared_ptr current_buffer; - if (!result_queue.try_pop(current_buffer)) - { - for (const auto &node : current_buffer->nodes) - { - extractor_callbacks->ProcessNode(node.first, - node.second); - } - for (auto &way : current_buffer->ways) - { - extractor_callbacks->ProcessWay(way.first, - way.second); - } - for (const auto &restriction : current_buffer->restrictions) - { - extractor_callbacks->ProcessRestriction(restriction); - } - - } - } - - loading_thread.join(); - - // TODO: join parser threads - - // while (osmium::memory::Buffer buffer = reader.read()) - // { - // for (osmium::OSMEntity &entity : buffer) + // std::shared_ptr result_buffer = std::make_shared();; + // for (osmium::OSMEntity &entity : *current_buffer) // { // switch (entity.type()) // { @@ -282,8 +217,7 @@ int Extractor::Run(int argc, char *argv[]) // "node_function", // boost::cref(static_cast(entity)), // boost::ref(result_node)); - // extractor_callbacks->ProcessNode(static_cast(entity), - // result_node); + // result_buffer->nodes.emplace_back(osmium::NodeRef{static_cast(entity).id(), static_cast(entity).location()}, result_node); // break; // case osmium::item_type::way: // ++number_of_ways; @@ -292,19 +226,85 @@ int Extractor::Run(int argc, char *argv[]) // "way_function", // boost::cref(static_cast(entity)), // boost::ref(result_way)); - // extractor_callbacks->ProcessWay(static_cast(entity), result_way); + // result_way.id = static_cast(entity).id(); + // result_buffer->ways.emplace_back(std::move(static_cast(entity).nodes()), result_way); // break; // case osmium::item_type::relation: // ++number_of_relations; - // extractor_callbacks->ProcessRestriction( - // restriction_parser.TryParse(static_cast(entity))); + // result_buffer->restrictions.emplace_back(restriction_parser.TryParse(static_cast(entity))); // break; // default: // ++number_of_others; // break; // } // } + // result_queue.push(result_buffer); + // parsing_done = true; // } + + // while (!parsing_done || !result_queue.empty()) + // { + // std::shared_ptr current_buffer; + // if (!result_queue.try_pop(current_buffer)) + // { + // for (const auto &node : current_buffer->nodes) + // { + // extractor_callbacks->ProcessNode(node.first, + // node.second); + // } + // for (auto &way : current_buffer->ways) + // { + // extractor_callbacks->ProcessWay(way.first, + // way.second); + // } + // for (const auto &restriction : current_buffer->restrictions) + // { + // extractor_callbacks->ProcessRestriction(restriction); + // } + + // } + // } + + // loading_thread.join(); + + // // TODO: join parser threads + + while (osmium::memory::Buffer buffer = reader.read()) + { + for (osmium::OSMEntity &entity : buffer) + { + switch (entity.type()) + { + case osmium::item_type::node: + ++number_of_nodes; + result_node.Clear(); + luabind::call_function(lua_state, + "node_function", + boost::cref(static_cast(entity)), + boost::ref(result_node)); + extractor_callbacks->ProcessNode(static_cast(entity), + result_node); + break; + case osmium::item_type::way: + ++number_of_ways; + result_way.Clear(); + luabind::call_function(lua_state, + "way_function", + boost::cref(static_cast(entity)), + boost::ref(result_way)); + extractor_callbacks->ProcessWay(static_cast(entity), result_way); + break; + case osmium::item_type::relation: + ++number_of_relations; + extractor_callbacks->ProcessRestriction( + restriction_parser.TryParse(static_cast(entity))); + break; + default: + ++number_of_others; + break; + } + } + } TIMER_STOP(parsing); SimpleLogger().Write() << "Parsing finished after " << TIMER_SEC(parsing) << " seconds"; SimpleLogger().Write() << "Raw input contains " << number_of_nodes << " nodes, " @@ -328,11 +328,6 @@ int Extractor::Run(int argc, char *argv[]) << "./osrm-prepare " << extractor_config.output_file_name << std::endl; } - catch (boost::program_options::too_many_positional_options_error &) - { - SimpleLogger().Write(logWARNING) << "Only one input file can be specified"; - return 1; - } catch (std::exception &e) { SimpleLogger().Write(logWARNING) << e.what(); diff --git a/Extractor/ExtractorCallbacks.cpp b/Extractor/ExtractorCallbacks.cpp index a14f09a2b..a7291faa4 100644 --- a/Extractor/ExtractorCallbacks.cpp +++ b/Extractor/ExtractorCallbacks.cpp @@ -48,13 +48,13 @@ ExtractorCallbacks::ExtractorCallbacks(ExtractionContainers &extraction_containe } /** warning: caller needs to take care of synchronization! */ -void ExtractorCallbacks::ProcessNode(const osmium::NodeRef &osm_input_node, +void ExtractorCallbacks::ProcessNode(const osmium::Node &input_node, const ExtractionNode &result_node) { external_memory.all_nodes_list.push_back({ - static_cast(osm_input_node.location().lat() * COORDINATE_PRECISION), - static_cast(osm_input_node.location().lon() * COORDINATE_PRECISION), - static_cast(osm_input_node.ref()), + static_cast(input_node.location().lat() * COORDINATE_PRECISION), + static_cast(input_node.location().lon() * COORDINATE_PRECISION), + static_cast(input_node.id()), result_node.barrier, result_node.traffic_lights }); @@ -69,7 +69,7 @@ void ExtractorCallbacks::ProcessRestriction( } } /** warning: caller needs to take care of synchronization! */ -void ExtractorCallbacks::ProcessWay(const osmium::WayNodeList &input_way, const ExtractionWay &parsed_way) +void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const ExtractionWay &parsed_way) { if (((0 >= parsed_way.forward_speed) || (TRAVEL_MODE_INACCESSIBLE == parsed_way.forward_travel_mode)) && @@ -80,7 +80,7 @@ void ExtractorCallbacks::ProcessWay(const osmium::WayNodeList &input_way, const return; } - if (input_way.size() <= 1) + if (input_way.nodes().size() <= 1) { // safe-guard against broken data return; } @@ -88,16 +88,15 @@ void ExtractorCallbacks::ProcessWay(const osmium::WayNodeList &input_way, const if (std::numeric_limits::max() == parsed_way.id) { SimpleLogger().Write(logDEBUG) << "found bogus way with id: " << parsed_way.id - << " of size " << input_way.size(); + << " of size " << input_way.nodes().size(); return; } - if (0 < parsed_way.duration) { // TODO: iterate all way segments and set duration corresponding to the length of each // segment - const_cast(parsed_way).forward_speed = parsed_way.duration / (input_way.size() - 1); - const_cast(parsed_way).backward_speed = parsed_way.duration / (input_way.size() - 1); + const_cast(parsed_way).forward_speed = parsed_way.duration / (input_way.nodes().size() - 1); + const_cast(parsed_way).backward_speed = parsed_way.duration / (input_way.nodes().size() - 1); } if (std::numeric_limits::epsilon() >= std::abs(-1. - parsed_way.forward_speed)) @@ -154,24 +153,23 @@ void ExtractorCallbacks::ProcessWay(const osmium::WayNodeList &input_way, const const_cast(parsed_way).forward_travel_mode = parsed_way.backward_travel_mode; const_cast(parsed_way).backward_travel_mode = TRAVEL_MODE_INACCESSIBLE; osrm::for_each_pair( - input_way.crbegin(), input_way.crend(), pair_wise_segment_split); - external_memory.used_node_id_list.push_back(input_way.front().ref()); + input_way.nodes().crbegin(), input_way.nodes().crend(), pair_wise_segment_split); + external_memory.used_node_id_list.push_back(input_way.nodes().front().ref()); } else { osrm::for_each_pair( - input_way.cbegin(), input_way.cend(), pair_wise_segment_split); - external_memory.used_node_id_list.push_back(input_way.back().ref()); + input_way.nodes().cbegin(), input_way.nodes().cend(), pair_wise_segment_split); + external_memory.used_node_id_list.push_back(input_way.nodes().back().ref()); } - // The following information is needed to identify start and end segments of restrictions // The following information is needed to identify start and end segments of restrictions external_memory.way_start_end_id_list.push_back( {(EdgeID)parsed_way.id, - (NodeID)input_way[0].ref(), - (NodeID)input_way[1].ref(), - (NodeID)input_way[input_way.size() - 2].ref(), - (NodeID)input_way.back().ref()}); + (NodeID)input_way.nodes()[0].ref(), + (NodeID)input_way.nodes()[1].ref(), + (NodeID)input_way.nodes()[input_way.nodes().size() - 2].ref(), + (NodeID)input_way.nodes().back().ref()}); if (split_edge) { // Only true if the way should be split @@ -198,24 +196,24 @@ void ExtractorCallbacks::ProcessWay(const osmium::WayNodeList &input_way, const if (is_opposite_way) { // SimpleLogger().Write() << "opposite2"; - osrm::for_each_pair(input_way.crbegin(), - input_way.crend(), + osrm::for_each_pair(input_way.nodes().crbegin(), + input_way.nodes().crend(), pair_wise_segment_split_2); - external_memory.used_node_id_list.push_back(input_way.front().ref()); + external_memory.used_node_id_list.push_back(input_way.nodes().front().ref()); } else { - osrm::for_each_pair(input_way.cbegin(), - input_way.cend(), + osrm::for_each_pair(input_way.nodes().cbegin(), + input_way.nodes().cend(), pair_wise_segment_split_2); - external_memory.used_node_id_list.push_back(input_way.back().ref()); + external_memory.used_node_id_list.push_back(input_way.nodes().back().ref()); } external_memory.way_start_end_id_list.push_back( {(EdgeID)parsed_way.id, - (NodeID)input_way[1].ref(), - (NodeID)input_way[0].ref(), - (NodeID)input_way.back().ref(), - (NodeID)input_way[input_way.size() - 2].ref()}); + (NodeID)input_way.nodes()[1].ref(), + (NodeID)input_way.nodes()[0].ref(), + (NodeID)input_way.nodes().back().ref(), + (NodeID)input_way.nodes()[input_way.nodes().size() - 2].ref()}); } } diff --git a/Extractor/ExtractorCallbacks.h b/Extractor/ExtractorCallbacks.h index baf0f7b67..7f700afa1 100644 --- a/Extractor/ExtractorCallbacks.h +++ b/Extractor/ExtractorCallbacks.h @@ -56,13 +56,13 @@ class ExtractorCallbacks std::unordered_map &string_map); // warning: caller needs to take care of synchronization! - void ProcessNode(const osmium::NodeRef ¤t_node, const ExtractionNode &result_node); + void ProcessNode(const osmium::Node ¤t_node, const ExtractionNode &result_node); // warning: caller needs to take care of synchronization! void ProcessRestriction(const mapbox::util::optional &restriction); // warning: caller needs to take care of synchronization! - void ProcessWay(const osmium::WayNodeList ¤t_way, const ExtractionWay &result_way); + void ProcessWay(const osmium::Way ¤t_way, const ExtractionWay &result_way); }; #endif /* EXTRACTOR_CALLBACKS_H */ diff --git a/Extractor/ExtractorOptions.cpp b/Extractor/ExtractorOptions.cpp index 7c9575b95..80e5772d3 100644 --- a/Extractor/ExtractorOptions.cpp +++ b/Extractor/ExtractorOptions.cpp @@ -29,7 +29,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "../Util/GitDescription.h" #include "../Util/IniFileUtil.h" -#include "../Util/SimpleLogger.h" +#include "../Util/simple_logger.hpp" #include #include diff --git a/Extractor/RestrictionParser.cpp b/Extractor/RestrictionParser.cpp index 5001bdfbc..690ad82ac 100644 --- a/Extractor/RestrictionParser.cpp +++ b/Extractor/RestrictionParser.cpp @@ -32,7 +32,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "../DataStructures/ExternalMemoryNode.h" #include "../Util/LuaUtil.h" #include "../Util/OSRMException.h" -#include "../Util/SimpleLogger.h" +#include "../Util/simple_logger.hpp" #include #include From 16631bf454e933985457f5f7bfb1c7247ec7c0e0 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Mon, 13 Oct 2014 13:53:46 +0200 Subject: [PATCH 65/80] port track smoothness to new parsing --- profiles/car.lua | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/profiles/car.lua b/profiles/car.lua index 58addb046..f42c96fdf 100644 --- a/profiles/car.lua +++ b/profiles/car.lua @@ -302,21 +302,21 @@ function way_function (way, result) end -- reduce speed on bad surfaces - local surface = way.tags:Find("surface") - local tracktype = way.tags:Find("tracktype") - local smoothness = way.tags:Find("smoothness") + local surface = way:get_value_by_key("surface") + local tracktype = way:get_value_by_key("tracktype") + local smoothness = way:get_value_by_key("smoothness") if surface and surface_speeds[surface] then - way.forward_speed = math.min(surface_speeds[surface], way.forward_speed) - way.backward_speed = math.min(surface_speeds[surface], way.backward_speed) + result.forward_speed = math.min(surface_speeds[surface], result.forward_speed) + result.backward_speed = math.min(surface_speeds[surface], result.backward_speed) end if tracktype and tracktype_speeds[tracktype] then - way.forward_speed = math.min(tracktype_speeds[tracktype], way.forward_speed) - way.backward_speed = math.min(tracktype_speeds[tracktype], way.backward_speed) + result.forward_speed = math.min(tracktype_speeds[tracktype], result.forward_speed) + result.backward_speed = math.min(tracktype_speeds[tracktype], result.backward_speed) end if smoothness and smoothness_speeds[smoothness] then - way.forward_speed = math.min(smoothness_speeds[smoothness], way.forward_speed) - way.backward_speed = math.min(smoothness_speeds[smoothness], way.backward_speed) + result.forward_speed = math.min(smoothness_speeds[smoothness], result.forward_speed) + result.backward_speed = math.min(smoothness_speeds[smoothness], result.backward_speed) end -- parse the remaining tags From a7c683a83cca9355b19bb18dfda77a3927edafbc Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Mon, 13 Oct 2014 15:51:40 +0200 Subject: [PATCH 66/80] forward way ID information properly in turn restrictions parsing --- Extractor/ExtractionContainers.cpp | 2 +- Extractor/ExtractionWay.h | 2 - Extractor/Extractor.cpp | 99 +----------------------------- Extractor/ExtractorCallbacks.cpp | 14 +++-- 4 files changed, 12 insertions(+), 105 deletions(-) diff --git a/Extractor/ExtractionContainers.cpp b/Extractor/ExtractionContainers.cpp index 204ab79c2..d934bd74e 100644 --- a/Extractor/ExtractionContainers.cpp +++ b/Extractor/ExtractionContainers.cpp @@ -102,7 +102,7 @@ void ExtractionContainers::PrepareData(const std::string &output_file_name, TIMER_STOP(sort_ways); std::cout << "ok, after " << TIMER_SEC(sort_ways) << "s" << std::endl; - std::cout << "[extractor] Sorting restrictions. by from... " << std::flush; + std::cout << "[extractor] Sorting " << restrictions_list.size() << " restrictions. by from... " << std::flush; TIMER_START(sort_restrictions); stxxl::sort(restrictions_list.begin(), restrictions_list.end(), diff --git a/Extractor/ExtractionWay.h b/Extractor/ExtractionWay.h index d42595a7b..740c4beaf 100644 --- a/Extractor/ExtractionWay.h +++ b/Extractor/ExtractionWay.h @@ -40,7 +40,6 @@ struct ExtractionWay void Clear() { - id = -1; forward_speed = -1; backward_speed = -1; duration = -1; @@ -107,7 +106,6 @@ struct ExtractionWay void set_backward_mode(const TravelMode m) { backward_travel_mode = m; } const TravelMode get_backward_mode() const { return backward_travel_mode; } - int64_t id; double forward_speed; double backward_speed; double duration; diff --git a/Extractor/Extractor.cpp b/Extractor/Extractor.cpp index 23a10f784..c5e3817cf 100644 --- a/Extractor/Extractor.cpp +++ b/Extractor/Extractor.cpp @@ -66,13 +66,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. namespace { -struct ResultBuffer -{ - std::vector> nodes; - std::vector> ways; - std::vector> restrictions; -}; - int lua_error_callback(lua_State *L) // This is so I can use my own function as an // exception handler, pcall_log() { @@ -178,96 +171,8 @@ int Extractor::Run(int argc, char *argv[]) RestrictionParser restriction_parser(scripting_environment); - // // move to header - // std::atomic_bool parsing_done {false}; - // std::atomic_bool loading_done {false}; - - // ConcurrentQueue> parse_queue(128); - // ConcurrentQueue> result_queue(128); - - // std::thread loading_thread([&]{ - // while (osmium::memory::Buffer buffer = reader.read()) - // { - // parse_queue.push(std::make_shared(std::move(buffer))); - // } - // loading_done = true; - // }); - - // // parsing threads - // while (!loading_done || !parse_queue.empty()) - // { - // std::shared_ptr current_buffer; - // if (!parse_queue.try_pop(current_buffer)) - // { - // continue; - // } - - ExtractionNode result_node; - ExtractionWay result_way; - - // std::shared_ptr result_buffer = std::make_shared();; - // for (osmium::OSMEntity &entity : *current_buffer) - // { - // switch (entity.type()) - // { - // case osmium::item_type::node: - // ++number_of_nodes; - // result_node.Clear(); - // luabind::call_function(lua_state, - // "node_function", - // boost::cref(static_cast(entity)), - // boost::ref(result_node)); - // result_buffer->nodes.emplace_back(osmium::NodeRef{static_cast(entity).id(), static_cast(entity).location()}, result_node); - // break; - // case osmium::item_type::way: - // ++number_of_ways; - // result_way.Clear(); - // luabind::call_function(lua_state, - // "way_function", - // boost::cref(static_cast(entity)), - // boost::ref(result_way)); - // result_way.id = static_cast(entity).id(); - // result_buffer->ways.emplace_back(std::move(static_cast(entity).nodes()), result_way); - // break; - // case osmium::item_type::relation: - // ++number_of_relations; - // result_buffer->restrictions.emplace_back(restriction_parser.TryParse(static_cast(entity))); - // break; - // default: - // ++number_of_others; - // break; - // } - // } - // result_queue.push(result_buffer); - // parsing_done = true; - // } - - // while (!parsing_done || !result_queue.empty()) - // { - // std::shared_ptr current_buffer; - // if (!result_queue.try_pop(current_buffer)) - // { - // for (const auto &node : current_buffer->nodes) - // { - // extractor_callbacks->ProcessNode(node.first, - // node.second); - // } - // for (auto &way : current_buffer->ways) - // { - // extractor_callbacks->ProcessWay(way.first, - // way.second); - // } - // for (const auto &restriction : current_buffer->restrictions) - // { - // extractor_callbacks->ProcessRestriction(restriction); - // } - - // } - // } - - // loading_thread.join(); - - // // TODO: join parser threads + ExtractionNode result_node; + ExtractionWay result_way; while (osmium::memory::Buffer buffer = reader.read()) { diff --git a/Extractor/ExtractorCallbacks.cpp b/Extractor/ExtractorCallbacks.cpp index a7291faa4..df56d7fd3 100644 --- a/Extractor/ExtractorCallbacks.cpp +++ b/Extractor/ExtractorCallbacks.cpp @@ -66,6 +66,10 @@ void ExtractorCallbacks::ProcessRestriction( if (restriction) { external_memory.restrictions_list.push_back(restriction.get()); + SimpleLogger().Write() << "from: " << restriction.get().restriction.from.node << + ",via: " << restriction.get().restriction.via.node << + ", to: " << restriction.get().restriction.to.node << + ", only: " << (restriction.get().restriction.flags.is_only ? "y" : "n"); } } /** warning: caller needs to take care of synchronization! */ @@ -85,9 +89,9 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti return; } - if (std::numeric_limits::max() == parsed_way.id) + if (std::numeric_limits::max() == input_way.id()) { - SimpleLogger().Write(logDEBUG) << "found bogus way with id: " << parsed_way.id + SimpleLogger().Write(logDEBUG) << "found bogus way with id: " << input_way.id() << " of size " << input_way.nodes().size(); return; } @@ -101,7 +105,7 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti if (std::numeric_limits::epsilon() >= std::abs(-1. - parsed_way.forward_speed)) { - SimpleLogger().Write(logDEBUG) << "found way with bogus speed, id: " << parsed_way.id; + SimpleLogger().Write(logDEBUG) << "found way with bogus speed, id: " << input_way.id(); return; } @@ -165,7 +169,7 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti // The following information is needed to identify start and end segments of restrictions external_memory.way_start_end_id_list.push_back( - {(EdgeID)parsed_way.id, + {(EdgeID)input_way.id(), (NodeID)input_way.nodes()[0].ref(), (NodeID)input_way.nodes()[1].ref(), (NodeID)input_way.nodes()[input_way.nodes().size() - 2].ref(), @@ -210,7 +214,7 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti } external_memory.way_start_end_id_list.push_back( - {(EdgeID)parsed_way.id, + {(EdgeID)input_way.id(), (NodeID)input_way.nodes()[1].ref(), (NodeID)input_way.nodes()[0].ref(), (NodeID)input_way.nodes().back().ref(), From 9d14f81b79144141a9607f4df963354a9e4d512e Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Mon, 20 Oct 2014 15:14:53 +0200 Subject: [PATCH 67/80] set default timestamp for tests --- features/step_definitions/timestamp.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/features/step_definitions/timestamp.rb b/features/step_definitions/timestamp.rb index ac80bee38..df456152b 100644 --- a/features/step_definitions/timestamp.rb +++ b/features/step_definitions/timestamp.rb @@ -3,5 +3,5 @@ Then /^I should get a valid timestamp/ do step "response should be valid JSON" step "response should be well-formed" expect(@json['timestamp'].class).to eq(String) - expect(@json['timestamp']).to eq("n/a") + expect(@json['timestamp']).to eq("2000-01-01T00:00:00Z") end From 0249bed53ae00c3fe78984b64837e632ba30eb47 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Thu, 23 Oct 2014 16:14:51 +0200 Subject: [PATCH 68/80] bump variant dependency --- ThirdParty/variant/optional.hpp | 9 - ThirdParty/variant/recursive_wrapper.hpp | 254 +++++++++++------------ 2 files changed, 127 insertions(+), 136 deletions(-) diff --git a/ThirdParty/variant/optional.hpp b/ThirdParty/variant/optional.hpp index 7c328da34..133e2c8f9 100644 --- a/ThirdParty/variant/optional.hpp +++ b/ThirdParty/variant/optional.hpp @@ -33,15 +33,6 @@ template class optional optional(T const &v) { variant_ = v; } - optional &operator=(optional other) - { // note: argument passed by value! - if (this != &other) - { - swap(other); - } - return *this; - } - explicit operator bool() const noexcept { return variant_.template is(); } T const &get() const { return variant_.template get(); } diff --git a/ThirdParty/variant/recursive_wrapper.hpp b/ThirdParty/variant/recursive_wrapper.hpp index 14879942b..54b27634a 100644 --- a/ThirdParty/variant/recursive_wrapper.hpp +++ b/ThirdParty/variant/recursive_wrapper.hpp @@ -1,127 +1,127 @@ -#ifndef MAPBOX_UTIL_VARIANT_RECURSIVE_WRAPPER_HPP -#define MAPBOX_UTIL_VARIANT_RECURSIVE_WRAPPER_HPP - -#include - -namespace mapbox { namespace util { - -template -class recursive_wrapper -{ -public: - using type = T; -private: - - T* p_; - -public: - - ~recursive_wrapper(); - recursive_wrapper(); - - recursive_wrapper(recursive_wrapper const& operand); - recursive_wrapper(T const& operand); - recursive_wrapper(recursive_wrapper&& operand); - recursive_wrapper(T&& operand); - -private: - - void assign(const T& rhs); - -public: - - inline recursive_wrapper& operator=(recursive_wrapper const& rhs) - { - assign( rhs.get() ); - return *this; - } - - inline recursive_wrapper& operator=(T const& rhs) - { - assign( rhs ); - return *this; - } - - inline void swap(recursive_wrapper& operand) noexcept - { - T* temp = operand.p_; - operand.p_ = p_; - p_ = temp; - } - - - recursive_wrapper& operator=(recursive_wrapper&& rhs) noexcept - { - swap(rhs); - return *this; - } - - recursive_wrapper& operator=(T&& rhs) - { - get() = std::move(rhs); - return *this; - } - - -public: - - T& get() { return *get_pointer(); } - const T& get() const { return *get_pointer(); } - T* get_pointer() { return p_; } - const T* get_pointer() const { return p_; } - operator T const&() const { return this->get(); } - operator T&() { return this->get(); } -}; - -template -recursive_wrapper::~recursive_wrapper() -{ - delete p_; -} - -template -recursive_wrapper::recursive_wrapper() - : p_(new T) -{ -} - -template -recursive_wrapper::recursive_wrapper(recursive_wrapper const& operand) - : p_(new T( operand.get() )) -{ -} - -template -recursive_wrapper::recursive_wrapper(T const& operand) - : p_(new T(operand)) -{ -} - -template -recursive_wrapper::recursive_wrapper(recursive_wrapper&& operand) - : p_(operand.p_) -{ - operand.p_ = nullptr; -} - -template -recursive_wrapper::recursive_wrapper(T&& operand) - : p_(new T( std::move(operand) )) -{ -} - -template -void recursive_wrapper::assign(const T& rhs) -{ - this->get() = rhs; -} - -template -inline void swap(recursive_wrapper& lhs, recursive_wrapper& rhs) noexcept -{ - lhs.swap(rhs); -} - -}} - -#endif // MAPBOX_UTIL_VARIANT_RECURSIVE_WRAPPER_HPP +#ifndef MAPBOX_UTIL_VARIANT_RECURSIVE_WRAPPER_HPP +#define MAPBOX_UTIL_VARIANT_RECURSIVE_WRAPPER_HPP + +#include + +namespace mapbox { namespace util { + +template +class recursive_wrapper +{ +public: + using type = T; +private: + + T* p_; + +public: + + ~recursive_wrapper(); + recursive_wrapper(); + + recursive_wrapper(recursive_wrapper const& operand); + recursive_wrapper(T const& operand); + recursive_wrapper(recursive_wrapper&& operand); + recursive_wrapper(T&& operand); + +private: + + void assign(const T& rhs); + +public: + + inline recursive_wrapper& operator=(recursive_wrapper const& rhs) + { + assign( rhs.get() ); + return *this; + } + + inline recursive_wrapper& operator=(T const& rhs) + { + assign( rhs ); + return *this; + } + + inline void swap(recursive_wrapper& operand) noexcept + { + T* temp = operand.p_; + operand.p_ = p_; + p_ = temp; + } + + + recursive_wrapper& operator=(recursive_wrapper&& rhs) noexcept + { + swap(rhs); + return *this; + } + + recursive_wrapper& operator=(T&& rhs) + { + get() = std::move(rhs); + return *this; + } + + +public: + + T& get() { return *get_pointer(); } + const T& get() const { return *get_pointer(); } + T* get_pointer() { return p_; } + const T* get_pointer() const { return p_; } + operator T const&() const { return this->get(); } + operator T&() { return this->get(); } +}; + +template +recursive_wrapper::~recursive_wrapper() +{ + delete p_; +} + +template +recursive_wrapper::recursive_wrapper() + : p_(new T) +{ +} + +template +recursive_wrapper::recursive_wrapper(recursive_wrapper const& operand) + : p_(new T( operand.get() )) +{ +} + +template +recursive_wrapper::recursive_wrapper(T const& operand) + : p_(new T(operand)) +{ +} + +template +recursive_wrapper::recursive_wrapper(recursive_wrapper&& operand) + : p_(operand.p_) +{ + operand.p_ = nullptr; +} + +template +recursive_wrapper::recursive_wrapper(T&& operand) + : p_(new T( std::move(operand) )) +{ +} + +template +void recursive_wrapper::assign(const T& rhs) +{ + this->get() = rhs; +} + +template +inline void swap(recursive_wrapper& lhs, recursive_wrapper& rhs) noexcept +{ + lhs.swap(rhs); +} + +}} + +#endif // MAPBOX_UTIL_VARIANT_RECURSIVE_WRAPPER_HPP From 710e74219a0e164d5e026602990378103ab7bcc5 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Wed, 29 Oct 2014 16:27:48 -0400 Subject: [PATCH 69/80] libosmium version bump --- ThirdParty/osmium/area/assembler.hpp | 58 +- .../osmium/area/detail/node_ref_segment.hpp | 65 +- ThirdParty/osmium/area/detail/proto_ring.hpp | 10 +- .../osmium/area/detail/segment_list.hpp | 12 +- .../osmium/area/multipolygon_collector.hpp | 422 +++---- ThirdParty/osmium/area/problem_reporter.hpp | 298 ++--- .../osmium/area/problem_reporter_ogr.hpp | 6 +- .../osmium/area/problem_reporter_stream.hpp | 192 +-- ThirdParty/osmium/builder/builder.hpp | 399 +++--- .../osmium/builder/osm_object_builder.hpp | 100 +- ThirdParty/osmium/dynamic_handler.hpp | 390 +++--- ThirdParty/osmium/geom/coordinates.hpp | 43 +- ThirdParty/osmium/geom/factory.hpp | 60 +- ThirdParty/osmium/geom/geojson.hpp | 11 +- ThirdParty/osmium/geom/haversine.hpp | 190 ++- .../osmium/geom/mercator_projection.hpp | 12 +- ThirdParty/osmium/geom/ogr.hpp | 24 +- ThirdParty/osmium/geom/projection.hpp | 4 +- ThirdParty/osmium/geom/util.hpp | 146 +-- ThirdParty/osmium/geom/wkb.hpp | 27 +- ThirdParty/osmium/geom/wkt.hpp | 12 +- ThirdParty/osmium/handler/chain.hpp | 256 ++-- ThirdParty/osmium/handler/dump.hpp | 588 ++++----- .../handler/node_locations_for_ways.hpp | 318 ++--- .../osmium/index/detail/mmap_vector_base.hpp | 366 +++--- .../osmium/index/detail/mmap_vector_file.hpp | 165 ++- ThirdParty/osmium/index/detail/tmpfile.hpp | 4 +- ThirdParty/osmium/index/detail/typed_mmap.hpp | 42 +- ThirdParty/osmium/index/map.hpp | 311 +++-- ThirdParty/osmium/index/map/sparse_table.hpp | 280 ++--- ThirdParty/osmium/index/map/stl_map.hpp | 224 ++-- ThirdParty/osmium/index/map/vector.hpp | 416 +++---- ThirdParty/osmium/index/multimap.hpp | 254 ++-- ThirdParty/osmium/index/multimap/hybrid.hpp | 398 +++--- .../osmium/index/multimap/stl_multimap.hpp | 302 ++--- ThirdParty/osmium/index/multimap/vector.hpp | 292 ++--- ThirdParty/osmium/io/bzip2_compression.hpp | 115 +- ThirdParty/osmium/io/compression.hpp | 83 +- ThirdParty/osmium/io/detail/input_format.hpp | 2 +- .../osmium/io/detail/opl_output_format.hpp | 22 +- ThirdParty/osmium/io/detail/pbf.hpp | 6 +- .../osmium/io/detail/pbf_input_format.hpp | 141 ++- .../osmium/io/detail/pbf_output_format.hpp | 33 +- .../osmium/io/detail/pbf_stringtable.hpp | 16 +- ThirdParty/osmium/io/detail/read_thread.hpp | 5 +- ThirdParty/osmium/io/detail/read_write.hpp | 64 +- .../osmium/io/detail/xml_input_format.hpp | 200 +-- .../osmium/io/detail/xml_output_format.hpp | 15 +- ThirdParty/osmium/io/detail/zlib.hpp | 4 +- ThirdParty/osmium/io/file.hpp | 677 ++++++----- ThirdParty/osmium/io/file_compression.hpp | 4 + ThirdParty/osmium/io/file_format.hpp | 4 + ThirdParty/osmium/io/gzip_compression.hpp | 128 +- ThirdParty/osmium/io/header.hpp | 12 +- ThirdParty/osmium/io/input_iterator.hpp | 6 +- ThirdParty/osmium/io/output_iterator.hpp | 230 ++-- ThirdParty/osmium/io/reader.hpp | 51 +- ThirdParty/osmium/io/writer.hpp | 3 +- ThirdParty/osmium/memory/buffer.hpp | 81 +- ThirdParty/osmium/memory/collection.hpp | 306 ++--- ThirdParty/osmium/memory/item.hpp | 40 +- ThirdParty/osmium/memory/item_iterator.hpp | 415 ++++--- .../osmium/object_pointer_collection.hpp | 224 ++-- ThirdParty/osmium/osm/area.hpp | 25 +- ThirdParty/osmium/osm/box.hpp | 10 +- ThirdParty/osmium/osm/changeset.hpp | 124 +- ThirdParty/osmium/osm/diff_object.hpp | 312 ++--- ThirdParty/osmium/osm/entity.hpp | 129 +- ThirdParty/osmium/osm/entity_bits.hpp | 8 +- ThirdParty/osmium/osm/item_type.hpp | 16 +- ThirdParty/osmium/osm/location.hpp | 56 +- ThirdParty/osmium/osm/node.hpp | 8 +- ThirdParty/osmium/osm/node_ref.hpp | 47 +- ThirdParty/osmium/osm/node_ref_list.hpp | 270 ++--- ThirdParty/osmium/osm/object.hpp | 190 +-- ThirdParty/osmium/osm/object_comparisons.hpp | 220 ++-- ThirdParty/osmium/osm/relation.hpp | 22 +- ThirdParty/osmium/osm/segment.hpp | 10 +- ThirdParty/osmium/osm/tag.hpp | 2 +- ThirdParty/osmium/osm/timestamp.hpp | 24 +- ThirdParty/osmium/osm/undirected_segment.hpp | 8 +- ThirdParty/osmium/osm/way.hpp | 230 ++-- ThirdParty/osmium/relations/collector.hpp | 1077 +++++++++-------- .../osmium/relations/detail/member_meta.hpp | 289 +++-- .../osmium/relations/detail/relation_meta.hpp | 272 ++--- ThirdParty/osmium/tags/filter.hpp | 12 +- ThirdParty/osmium/tags/regex_filter.hpp | 116 +- ThirdParty/osmium/thread/function_wrapper.hpp | 208 ++-- ThirdParty/osmium/thread/pool.hpp | 384 +++--- ThirdParty/osmium/util/compatibility.hpp | 6 +- ThirdParty/osmium/util/verbose_output.hpp | 2 +- 91 files changed, 7244 insertions(+), 6417 deletions(-) diff --git a/ThirdParty/osmium/area/assembler.hpp b/ThirdParty/osmium/area/assembler.hpp index 5c8e6c906..155fa24c2 100644 --- a/ThirdParty/osmium/area/assembler.hpp +++ b/ThirdParty/osmium/area/assembler.hpp @@ -152,15 +152,26 @@ namespace osmium { } } + 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 { - osmium::tags::KeyFilter filter(true); - filter.add(false, "type").add(false, "created_by").add(false, "source").add(false, "note"); - filter.add(false, "test:id").add(false, "test:section"); - - osmium::tags::KeyFilter::iterator fi_begin(filter, relation.tags().begin(), relation.tags().end()); - osmium::tags::KeyFilter::iterator fi_end(filter, relation.tags().end(), relation.tags().end()); - - auto count = std::distance(fi_begin, fi_end); + 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"; @@ -728,27 +739,26 @@ namespace osmium { const osmium::TagList& area_tags = out_buffer.get(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 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(offset); if (way.is_closed() && way.tags().size() > 0) { - osmium::tags::KeyFilter filter(true); - filter.add(false, "created_by").add(false, "source").add(false, "note"); - filter.add(false, "test:id").add(false, "test:section"); - - osmium::tags::KeyFilter::iterator fi_begin(filter, way.tags().begin(), way.tags().end()); - osmium::tags::KeyFilter::iterator fi_end(filter, way.tags().end(), way.tags().end()); - - auto d = std::distance(fi_begin, fi_end); + auto d = std::count_if(way.tags().begin(), way.tags().end(), filter()); if (d > 0) { - 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()); + 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(fi_begin, fi_end, area_fi_begin) || d != std::distance(area_fi_begin, area_fi_end)) { - Assembler assembler(m_config); - assembler(way, out_buffer); + 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); } } } @@ -756,6 +766,12 @@ namespace osmium { ++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 diff --git a/ThirdParty/osmium/area/detail/node_ref_segment.hpp b/ThirdParty/osmium/area/detail/node_ref_segment.hpp index 62905d675..5b251bb5b 100644 --- a/ThirdParty/osmium/area/detail/node_ref_segment.hpp +++ b/ThirdParty/osmium/area/detail/node_ref_segment.hpp @@ -78,7 +78,7 @@ namespace osmium { swap(m_first, m_second); } - explicit NodeRefSegment() : + explicit NodeRefSegment() noexcept : m_first(), m_second(), m_role(nullptr), @@ -104,12 +104,12 @@ namespace osmium { ~NodeRefSegment() = default; /// Return first NodeRef of Segment according to sorting order (bottom left to top right). - const osmium::NodeRef& first() const { + 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 { + const osmium::NodeRef& second() const noexcept { return m_second; } @@ -138,26 +138,26 @@ namespace osmium { return ((bx - ax)*(ly - ay) - (by - ay)*(lx - ax)) <= 0; } - bool role_outer() const { + bool role_outer() const noexcept { return !strcmp(m_role, "outer"); } - bool role_inner() const { + bool role_inner() const noexcept { return !strcmp(m_role, "inner"); } - const osmium::Way* way() const { + 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) { + 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) { + inline bool operator!=(const NodeRefSegment& lhs, const NodeRefSegment& rhs) noexcept { return ! (lhs == rhs); } @@ -166,19 +166,19 @@ namespace osmium { * 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) { + 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) { + inline bool operator>(const NodeRefSegment& lhs, const NodeRefSegment& rhs) noexcept { return rhs < lhs; } - inline bool operator<=(const NodeRefSegment& lhs, const NodeRefSegment& rhs) { + inline bool operator<=(const NodeRefSegment& lhs, const NodeRefSegment& rhs) noexcept { return ! (rhs < lhs); } - inline bool operator>=(const NodeRefSegment& lhs, const NodeRefSegment& rhs) { + inline bool operator>=(const NodeRefSegment& lhs, const NodeRefSegment& rhs) noexcept { return ! (lhs < rhs); } @@ -187,7 +187,7 @@ namespace osmium { return out << segment.first() << "--" << segment.second(); } - inline bool outside_x_range(const NodeRefSegment& s1, const NodeRefSegment& s2) { + inline bool outside_x_range(const NodeRefSegment& s1, const NodeRefSegment& s2) noexcept { if (s1.first().location().x() > s2.second().location().x()) { return true; } @@ -204,20 +204,20 @@ namespace osmium { } /** - * Calculate the intersection between to 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. - * - * 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. - */ + * Calculate the intersection between to 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. + * + * 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() || @@ -226,10 +226,15 @@ namespace osmium { return osmium::Location(); } - double denom = ((s2.second().lat() - s2.first().lat())*(s1.second().lon() - s1.first().lon())) - - ((s2.second().lon() - s2.first().lon())*(s1.second().lat() - s1.first().lat())); + auto d = (static_cast(s2.second().y()) - static_cast(s2.first().y())) * + (static_cast(s1.second().x()) - static_cast(s1.first().x())) - + (static_cast(s2.second().x()) - static_cast(s2.first().x())) * + (static_cast(s1.second().y()) - static_cast(s1.first().y())); + + if (d != 0) { + double denom = ((s2.second().lat() - s2.first().lat())*(s1.second().lon() - s1.first().lon())) - + ((s2.second().lon() - s2.first().lon())*(s1.second().lat() - s1.first().lat())); - if (denom != 0) { double nume_a = ((s2.second().lon() - s2.first().lon())*(s1.first().lat() - s2.first().lat())) - ((s2.second().lat() - s2.first().lat())*(s1.first().lon() - s2.first().lon())); diff --git a/ThirdParty/osmium/area/detail/proto_ring.hpp b/ThirdParty/osmium/area/detail/proto_ring.hpp index 1dd236d21..63fec5b79 100644 --- a/ThirdParty/osmium/area/detail/proto_ring.hpp +++ b/ThirdParty/osmium/area/detail/proto_ring.hpp @@ -70,7 +70,7 @@ namespace osmium { public: - explicit ProtoRing(const NodeRefSegment& segment) : + explicit ProtoRing(const NodeRefSegment& segment) noexcept : m_segments() { add_segment_back(segment); } @@ -80,19 +80,19 @@ namespace osmium { std::copy(sbegin, send, m_segments.begin()); } - bool outer() const { + bool outer() const noexcept { return m_outer; } - void set_inner() { + void set_inner() noexcept { m_outer = false; } - segments_type& segments() { + segments_type& segments() noexcept { return m_segments; } - const segments_type& segments() const { + const segments_type& segments() const noexcept { return m_segments; } diff --git a/ThirdParty/osmium/area/detail/segment_list.hpp b/ThirdParty/osmium/area/detail/segment_list.hpp index dcee3d00a..7bb887d79 100644 --- a/ThirdParty/osmium/area/detail/segment_list.hpp +++ b/ThirdParty/osmium/area/detail/segment_list.hpp @@ -64,7 +64,7 @@ namespace osmium { public: - explicit SegmentList(bool debug) : + explicit SegmentList(bool debug) noexcept : m_debug(debug) { } @@ -77,21 +77,21 @@ namespace osmium { SegmentList& operator=(SegmentList&& other) = delete; /// The number of segments in the list. - size_t size() const { + size_t size() const noexcept { return m_segments.size(); } - bool empty() const { + bool empty() const noexcept { return m_segments.empty(); } typedef slist_type::const_iterator const_iterator; - const_iterator begin() const { + const_iterator begin() const noexcept { return m_segments.begin(); } - const_iterator end() const { + const_iterator end() const noexcept { return m_segments.end(); } @@ -99,7 +99,7 @@ namespace osmium { * Enable or disable debug output to stderr. This is for Osmium * developers only. */ - void enable_debug_output(bool debug=true) { + void enable_debug_output(bool debug=true) noexcept { m_debug = debug; } diff --git a/ThirdParty/osmium/area/multipolygon_collector.hpp b/ThirdParty/osmium/area/multipolygon_collector.hpp index 24aa89c48..f02eff5fb 100644 --- a/ThirdParty/osmium/area/multipolygon_collector.hpp +++ b/ThirdParty/osmium/area/multipolygon_collector.hpp @@ -1,211 +1,211 @@ -#ifndef OSMIUM_AREA_MULTIPOLYGON_COLLECTOR_HPP -#define OSMIUM_AREA_MULTIPOLYGON_COLLECTOR_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2014 Jochen Topf 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 -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include -#include - -namespace osmium { - - struct invalid_location; - - namespace relations { - class RelationMeta; - } - - /** - * @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 - class MultipolygonCollector : public osmium::relations::Collector, false, true, false> { - - typedef typename osmium::relations::Collector, 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()) { - this->callback()(m_output_buffer); - m_output_buffer.clear(); - } - } - - 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) { - if (way.ends_have_same_location() && way.nodes().size() > 3) { - // way is closed and has enough nodes, build simple multipolygon - try { - 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 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 - } - - // clear member metas - for (const auto& member : relation.members()) { - if (member.ref() != 0) { - auto& mmv = this->member_meta(member.type()); - auto range = std::equal_range(mmv.begin(), mmv.end(), osmium::relations::MemberMeta(member.ref())); - assert(range.first != range.second); - - // if this is the last time this object was needed - // then mark it as removed - if (range.first + 1 == range.second) { - this->get_member(range.first->buffer_offset()).removed(true); - } - - for (auto it = range.first; it != range.second; ++it) { - if (relation.id() == this->get_relation(it->relation_pos()).id()) { - mmv.erase(it); - break; - } - } - } - } - } - - void flush() { - flush_output_buffer(); - } - - osmium::memory::Buffer read() { - osmium::memory::Buffer buffer(initial_output_buffer_size, osmium::memory::Buffer::auto_grow::yes); - std::swap(buffer, m_output_buffer); - return buffer; - } - - }; // class MultipolygonCollector - - } // namespace area - -} // namespace osmium - -#endif // OSMIUM_AREA_MULTIPOLYGON_COLLECTOR_HPP +#ifndef OSMIUM_AREA_MULTIPOLYGON_COLLECTOR_HPP +#define OSMIUM_AREA_MULTIPOLYGON_COLLECTOR_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2014 Jochen Topf 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 +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +namespace osmium { + + struct invalid_location; + + namespace relations { + class RelationMeta; + } + + /** + * @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 + class MultipolygonCollector : public osmium::relations::Collector, false, true, false> { + + typedef typename osmium::relations::Collector, 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()) { + this->callback()(m_output_buffer); + m_output_buffer.clear(); + } + } + + 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) { + if (way.ends_have_same_location() && way.nodes().size() > 3) { + // way is closed and has enough nodes, build simple multipolygon + try { + 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 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 + } + + // clear member metas + for (const auto& member : relation.members()) { + if (member.ref() != 0) { + auto& mmv = this->member_meta(member.type()); + auto range = std::equal_range(mmv.begin(), mmv.end(), osmium::relations::MemberMeta(member.ref())); + assert(range.first != range.second); + + // if this is the last time this object was needed + // then mark it as removed + if (osmium::relations::count_not_removed(range.first, range.second) == 1) { + this->get_member(range.first->buffer_offset()).set_removed(true); + } + + for (auto it = range.first; it != range.second; ++it) { + if (!it->removed() && relation.id() == this->get_relation(it->relation_pos()).id()) { + it->remove(); + break; + } + } + } + } + } + + void flush() { + flush_output_buffer(); + } + + osmium::memory::Buffer read() { + osmium::memory::Buffer buffer(initial_output_buffer_size, osmium::memory::Buffer::auto_grow::yes); + std::swap(buffer, m_output_buffer); + return buffer; + } + + }; // class MultipolygonCollector + + } // namespace area + +} // namespace osmium + +#endif // OSMIUM_AREA_MULTIPOLYGON_COLLECTOR_HPP diff --git a/ThirdParty/osmium/area/problem_reporter.hpp b/ThirdParty/osmium/area/problem_reporter.hpp index 9e3eece8d..5e255db50 100644 --- a/ThirdParty/osmium/area/problem_reporter.hpp +++ b/ThirdParty/osmium/area/problem_reporter.hpp @@ -1,149 +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 2014 Jochen Topf 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 -#include -#include - -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) { - 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 +#ifndef OSMIUM_AREA_PROBLEM_REPORTER_HPP +#define OSMIUM_AREA_PROBLEM_REPORTER_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2014 Jochen Topf 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 +#include +#include + +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 diff --git a/ThirdParty/osmium/area/problem_reporter_ogr.hpp b/ThirdParty/osmium/area/problem_reporter_ogr.hpp index f1bcf87ac..a9eb1359f 100644 --- a/ThirdParty/osmium/area/problem_reporter_ogr.hpp +++ b/ThirdParty/osmium/area/problem_reporter_ogr.hpp @@ -37,10 +37,14 @@ DEALINGS IN THE SOFTWARE. #define OSMIUM_LINK_WITH_LIBS_OGR `gdal-config --libs` #pragma GCC diagnostic push +#ifdef __clang__ +# pragma GCC diagnostic ignored "-Wdocumentation-unknown-command" +#endif +#pragma GCC diagnostic ignored "-Wfloat-equal" #pragma GCC diagnostic ignored "-Wold-style-cast" +#pragma GCC diagnostic ignored "-Wpadded" #pragma GCC diagnostic ignored "-Wredundant-decls" #pragma GCC diagnostic ignored "-Wshadow" -#pragma GCC diagnostic ignored "-Wdocumentation-unknown-command" # include # include #pragma GCC diagnostic pop diff --git a/ThirdParty/osmium/area/problem_reporter_stream.hpp b/ThirdParty/osmium/area/problem_reporter_stream.hpp index 3ff2f20bb..6bee56816 100644 --- a/ThirdParty/osmium/area/problem_reporter_stream.hpp +++ b/ThirdParty/osmium/area/problem_reporter_stream.hpp @@ -1,96 +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 2014 Jochen Topf 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 - -#include -#include -#include -#include - -namespace osmium { - - namespace area { - - class ProblemReporterStream : public ProblemReporter { - - std::ostream& m_out; - - public: - - explicit ProblemReporterStream(std::ostream& out) : - m_out(out) { - } - - virtual ~ProblemReporterStream() = 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 +#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 2014 Jochen Topf 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 + +#include +#include +#include +#include + +namespace osmium { + + namespace area { + + class ProblemReporterStream : public ProblemReporter { + + std::ostream* m_out; + + public: + + explicit ProblemReporterStream(std::ostream& out) : + m_out(&out) { + } + + virtual ~ProblemReporterStream() = 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 diff --git a/ThirdParty/osmium/builder/builder.hpp b/ThirdParty/osmium/builder/builder.hpp index bd762be2c..61e853e70 100644 --- a/ThirdParty/osmium/builder/builder.hpp +++ b/ThirdParty/osmium/builder/builder.hpp @@ -1,179 +1,220 @@ -#ifndef OSMIUM_BUILDER_BUILDER_HPP -#define OSMIUM_BUILDER_BUILDER_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 -#include -#include -#include -#include - -#include -#include - -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, size_t 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(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) { - size_t padding = osmium::memory::align_bytes - (size() % osmium::memory::align_bytes); - if (padding != osmium::memory::align_bytes) { - std::memset(m_buffer.reserve_space(padding), 0, padding); - 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 { - return item().byte_size(); - } - - void add_item(const osmium::memory::Item* item) { - std::memcpy(m_buffer.reserve_space(item->padded_size()), item, item->padded_size()); - add_size(item->padded_size()); - } - - /** - * Reserve space for an object of class T in buffer and return - * pointer to it. - */ - template - T* reserve_space_for() { - assert(m_buffer.is_aligned()); - return reinterpret_cast(m_buffer.reserve_space(sizeof(T))); - } - - /** - * Append \0-terminated string to buffer. - */ - size_t append(const char* str) { - size_t length = std::strlen(str) + 1; - std::memcpy(m_buffer.reserve_space(length), str, length); - return length; - } - - /// Return the buffer this builder is using. - osmium::memory::Buffer& buffer() { - return m_buffer; - } - - }; // class Builder - - template - class ObjectBuilder : public Builder { - - public: - - explicit ObjectBuilder(osmium::memory::Buffer& buffer, Builder* parent=nullptr) : - Builder(buffer, parent, sizeof(T)) { - new (&item()) T(); - } - - T& object() { - return static_cast(item()); - } - - void add_user(const char* user) { - object().user_size(std::strlen(user) + 1); - add_size(append(user)); - add_padding(true); - } - - }; // class ObjectBuilder - - } // namespace builder - -} // namespace osmium - -#endif // OSMIUM_BUILDER_BUILDER_HPP +#ifndef OSMIUM_BUILDER_BUILDER_HPP +#define OSMIUM_BUILDER_BUILDER_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +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(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::memset(m_buffer.reserve_space(padding), 0, padding); + 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) { + std::memcpy(m_buffer.reserve_space(item->padded_size()), item, item->padded_size()); + add_size(item->padded_size()); + } + + /** + * Reserve space for an object of class T in buffer and return + * pointer to it. + */ + template + T* reserve_space_for() { + assert(m_buffer.is_aligned()); + return reinterpret_cast(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. + */ + osmium::memory::item_size_type append(const char* data, const osmium::memory::item_size_type length) { + std::memcpy(m_buffer.reserve_space(length), data, length); + return length; + } + + /** + * Append \0-terminated string to buffer. + */ + osmium::memory::item_size_type append(const char* str) { + return append(str, static_cast(std::strlen(str) + 1)); + } + + /// Return the buffer this builder is using. + osmium::memory::Buffer& buffer() noexcept { + return m_buffer; + } + + }; // class Builder + + template + class ObjectBuilder : public Builder { + + static_assert(std::is_base_of::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(item()); + } + + /** + * Add user name to buffer. + * + * @param user Pointer to user name. + * @param length Length of user name including \0 byte. + */ + void add_user(const char* user, const string_size_type length) { + object().set_user_size(length); + add_size(append(user, length)); + 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(std::strlen(user) + 1)); + } + + /** + * Add user name to buffer. + * + * @param user User name. + */ + void add_user(const std::string& user) { + add_user(user.data(), static_cast_with_assert(user.size() + 1)); + } + + }; // class ObjectBuilder + + } // namespace builder + +} // namespace osmium + +#endif // OSMIUM_BUILDER_BUILDER_HPP diff --git a/ThirdParty/osmium/builder/osm_object_builder.hpp b/ThirdParty/osmium/builder/osm_object_builder.hpp index 0fb26c8ae..851eb85f8 100644 --- a/ThirdParty/osmium/builder/osm_object_builder.hpp +++ b/ThirdParty/osmium/builder/osm_object_builder.hpp @@ -46,6 +46,7 @@ DEALINGS IN THE SOFTWARE. #include #include #include +#include namespace osmium { @@ -67,10 +68,27 @@ namespace osmium { add_padding(); } + /** + * Add tag to buffer. + * + * @param key Tag key. + * @param value Tag value. + */ void add_tag(const char* key, const char* value) { add_size(append(key) + append(value)); } + /** + * Add tag to buffer. + * + * @param key Tag key. + * @param value Tag value. + */ + void add_tag(const std::string& key, const std::string& value) { + add_size(append(key.data(), static_cast_with_assert(key.size() + 1)) + + append(value.data(), static_cast_with_assert(value.size() + 1))); + } + }; // class TagListBuilder template @@ -103,14 +121,42 @@ namespace osmium { class RelationMemberListBuilder : public ObjectBuilder { - void add_role(osmium::RelationMember* member, const char* role) { - size_t length = std::strlen(role) + 1; - assert(length < std::numeric_limits::max()); - member->set_role_size(static_cast(length)); - add_size(append(role)); + /** + * 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 string including \0 termination. + */ + void add_role(osmium::RelationMember& member, const char* role, const string_size_type length) { + member.set_role_size(length); + add_size(append(role, length)); add_padding(true); } + /** + * Add role to buffer. + * + * @param member Relation member object where the length of the role + * will be set. + * @param role \0-terminated role. + */ + void add_role(osmium::RelationMember& member, const char* role) { + add_role(member, role, static_cast_with_assert(std::strlen(role) + 1)); + } + + /** + * Add role to buffer. + * + * @param member Relation member object where the length of the role + * will be set. + * @param role Role. + */ + void add_role(osmium::RelationMember& member, const std::string& role) { + add_role(member, role.data(), static_cast_with_assert(role.size() + 1)); + } + public: explicit RelationMemberListBuilder(osmium::memory::Buffer& buffer, Builder* parent=nullptr) : @@ -121,11 +167,41 @@ namespace osmium { 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 full_member Optional pointer to the member object. If it + * is available a copy will be added to the + * relation. + */ void add_member(osmium::item_type type, object_id_type ref, const char* role, const osmium::OSMObject* full_member = nullptr) { osmium::RelationMember* member = reserve_space_for(); new (member) osmium::RelationMember(ref, type, full_member != nullptr); add_size(sizeof(RelationMember)); - add_role(member, role); + add_role(*member, role); + 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. + * @param full_member Optional pointer to the member object. If it + * is available a copy will be added to the + * relation. + */ + void add_member(osmium::item_type type, object_id_type ref, const std::string& role, const osmium::OSMObject* full_member = nullptr) { + osmium::RelationMember* member = reserve_space_for(); + new (member) osmium::RelationMember(ref, type, full_member != nullptr); + add_size(sizeof(RelationMember)); + add_role(*member, role); if (full_member) { add_item(full_member); } @@ -186,12 +262,12 @@ namespace osmium { */ void initialize_from_object(const osmium::OSMObject& source) { osmium::Area& area = object(); - area.id(osmium::object_id_to_area_id(source.id(), source.type())); - area.version(source.version()); - area.changeset(source.changeset()); - area.timestamp(source.timestamp()); - area.visible(source.visible()); - area.uid(source.uid()); + 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()); } diff --git a/ThirdParty/osmium/dynamic_handler.hpp b/ThirdParty/osmium/dynamic_handler.hpp index 115c09d3d..bc593131c 100644 --- a/ThirdParty/osmium/dynamic_handler.hpp +++ b/ThirdParty/osmium/dynamic_handler.hpp @@ -1,195 +1,195 @@ -#ifndef OSMIUM_DYNAMIC_HANDLER_HPP -#define OSMIUM_DYNAMIC_HANDLER_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 -#include - -#include - -namespace osmium { - - class Node; - class Way; - class Relation; - class Area; - class Changeset; - - 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 \ -auto _name_##_dispatch(THandler& handler, const osmium::_type_& object, int) -> decltype(handler._name_(object), void()) { \ - handler._name_(object); \ -} \ -template \ -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 - auto flush_dispatch(THandler& handler, int) -> decltype(handler.flush(), void()) { - handler.flush(); - } - - template - void flush_dispatch(THandler&, long) {} - - template - class HandlerWrapper : public HandlerWrapperBase { - - THandler m_handler; - - public: - - template - HandlerWrapper(TArgs&&... args) : - m_handler(std::forward(args)...) { - } - - void node(const osmium::Node& node) override final { - node_dispatch(m_handler, node, 0); - } - - void way(const osmium::Way& way) override final { - way_dispatch(m_handler, way, 0); - } - - void relation(const osmium::Relation& relation) override final { - relation_dispatch(m_handler, relation, 0); - } - - void area(const osmium::Area& area) override final { - area_dispatch(m_handler, area, 0); - } - - void changeset(const osmium::Changeset& changeset) override final { - changeset_dispatch(m_handler, changeset, 0); - } - - void flush() override final { - flush_dispatch(m_handler, 0); - } - - }; // HandlerWrapper - - } // namespace detail - - class DynamicHandler : public osmium::handler::Handler { - - typedef std::unique_ptr impl_ptr; - impl_ptr m_impl; - - public: - - DynamicHandler() : - m_impl(impl_ptr(new osmium::handler::detail::HandlerWrapperBase)) { - } - - template - void set(TArgs&&... args) { - m_impl = impl_ptr(new osmium::handler::detail::HandlerWrapper(std::forward(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(); - } - - }; // DynamicHandler - - } // namspace handler - -} // namespace osmium - -#endif // OSMIUM_DYNAMIC_HANDLER_HPP +#ifndef OSMIUM_DYNAMIC_HANDLER_HPP +#define OSMIUM_DYNAMIC_HANDLER_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include + +#include + +namespace osmium { + + class Node; + class Way; + class Relation; + class Area; + class Changeset; + + 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 \ +auto _name_##_dispatch(THandler& handler, const osmium::_type_& object, int) -> decltype(handler._name_(object), void()) { \ + handler._name_(object); \ +} \ +template \ +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 + auto flush_dispatch(THandler& handler, int) -> decltype(handler.flush(), void()) { + handler.flush(); + } + + template + void flush_dispatch(THandler&, long) {} + + template + class HandlerWrapper : public HandlerWrapperBase { + + THandler m_handler; + + public: + + template + HandlerWrapper(TArgs&&... args) : + m_handler(std::forward(args)...) { + } + + void node(const osmium::Node& node) override final { + node_dispatch(m_handler, node, 0); + } + + void way(const osmium::Way& way) override final { + way_dispatch(m_handler, way, 0); + } + + void relation(const osmium::Relation& relation) override final { + relation_dispatch(m_handler, relation, 0); + } + + void area(const osmium::Area& area) override final { + area_dispatch(m_handler, area, 0); + } + + void changeset(const osmium::Changeset& changeset) override final { + changeset_dispatch(m_handler, changeset, 0); + } + + void flush() override final { + flush_dispatch(m_handler, 0); + } + + }; // class HandlerWrapper + + } // namespace detail + + class DynamicHandler : public osmium::handler::Handler { + + typedef std::unique_ptr impl_ptr; + impl_ptr m_impl; + + public: + + DynamicHandler() : + m_impl(impl_ptr(new osmium::handler::detail::HandlerWrapperBase)) { + } + + template + void set(TArgs&&... args) { + m_impl = impl_ptr(new osmium::handler::detail::HandlerWrapper(std::forward(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 + + } // namspace handler + +} // namespace osmium + +#endif // OSMIUM_DYNAMIC_HANDLER_HPP diff --git a/ThirdParty/osmium/geom/coordinates.hpp b/ThirdParty/osmium/geom/coordinates.hpp index 694143c22..1ff27fea4 100644 --- a/ThirdParty/osmium/geom/coordinates.hpp +++ b/ThirdParty/osmium/geom/coordinates.hpp @@ -38,59 +38,50 @@ DEALINGS IN THE SOFTWARE. #include #include +#include namespace osmium { namespace geom { - namespace detail { - - /** - * Append double to string, removing superfluous '0' characters at - * the end. The decimal dot will also be removed if necessary. - */ - inline void double2string(std::string& s, double value) { - s += std::to_string(value); - - size_t len = s.size()-1; - while (s[len] == '0') --len; - if (s[len] == '.') --len; - - s.resize(len+1); - } - - } // namespace detail - struct Coordinates { double x; double y; - explicit Coordinates(double cx, double cy) : x(cx), y(cy) { + 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) const { - osmium::geom::detail::double2string(s, x); + void append_to_string(std::string& s, const char infix, int precision) const { + osmium::util::double2string(s, x, precision); s += infix; - osmium::geom::detail::double2string(s, y); + osmium::util::double2string(s, y, precision); } - void append_to_string(std::string& s, const char prefix, const char infix, const char suffix) const { + 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); + append_to_string(s, infix, precision); s += suffix; } }; // struct coordinates - inline bool operator==(const Coordinates& lhs, const Coordinates& rhs) { + /** + * 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) { + inline bool operator!=(const Coordinates& lhs, const Coordinates& rhs) noexcept { return ! operator==(lhs, rhs); } diff --git a/ThirdParty/osmium/geom/factory.hpp b/ThirdParty/osmium/geom/factory.hpp index 1be404848..4097b5dac 100644 --- a/ThirdParty/osmium/geom/factory.hpp +++ b/ThirdParty/osmium/geom/factory.hpp @@ -33,6 +33,7 @@ DEALINGS IN THE SOFTWARE. */ +#include #include #include #include @@ -49,6 +50,10 @@ DEALINGS IN THE SOFTWARE. namespace osmium { + /** + * Exception thrown when an invalid geometry is encountered. An example + * would be a linestring with less than two points. + */ struct geometry_error : public std::runtime_error { geometry_error(const std::string& what) : @@ -72,7 +77,7 @@ namespace osmium { 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 @@ -81,7 +86,7 @@ namespace osmium { 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. @@ -95,7 +100,7 @@ namespace osmium { return Coordinates{location.lon(), location.lat()}; } - int epsg() const { + int epsg() const noexcept { return 4326; } @@ -178,6 +183,10 @@ namespace osmium { /* LineString */ + void linestring_start() { + m_impl.linestring_start(); + } + template size_t fill_linestring(TIter it, TIter end) { size_t num_points = 0; @@ -201,8 +210,12 @@ namespace osmium { 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) { - m_impl.linestring_start(); + linestring_start(); size_t num_points = 0; if (un == use_nodes::unique) { @@ -227,16 +240,49 @@ namespace osmium { } if (num_points < 2) { - throw geometry_error("not enough points for linestring"); + throw osmium::geometry_error("not enough points for linestring"); } - return m_impl.linestring_finish(num_points); + return linestring_finish(num_points); } linestring_type create_linestring(const osmium::Way& way, use_nodes un=use_nodes::unique, direction dir=direction::forward) { return create_linestring(way.nodes(), un, dir); } + /* Polygon */ + + void polygon_start() { + m_impl.polygon_start(); + } + + template + 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 + 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); + } + /* MultiPolygon */ multipolygon_type create_multipolygon(const osmium::Area& area) { @@ -266,7 +312,7 @@ namespace osmium { // if there are no rings, this area is invalid if (num_rings == 0) { - throw geometry_error("invalid area"); + throw osmium::geometry_error("invalid area"); } m_impl.multipolygon_polygon_finish(); diff --git a/ThirdParty/osmium/geom/geojson.hpp b/ThirdParty/osmium/geom/geojson.hpp index 89efc3831..f6d7ee6e4 100644 --- a/ThirdParty/osmium/geom/geojson.hpp +++ b/ThirdParty/osmium/geom/geojson.hpp @@ -49,6 +49,7 @@ namespace osmium { class GeoJSONFactoryImpl { std::string m_str; + int m_precision; public: @@ -58,14 +59,16 @@ namespace osmium { typedef std::string multipolygon_type; typedef std::string ring_type; - GeoJSONFactoryImpl() = default; + 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, '[', ',', ']'); + xy.append_to_string(str, '[', ',', ']', m_precision); str += "}"; return str; } @@ -78,7 +81,7 @@ namespace osmium { } void linestring_add_location(const osmium::geom::Coordinates& xy) { - xy.append_to_string(m_str, '[', ',', ']'); + xy.append_to_string(m_str, '[', ',', ']', m_precision); m_str += ','; } @@ -124,7 +127,7 @@ namespace osmium { } void multipolygon_add_location(const osmium::geom::Coordinates& xy) { - xy.append_to_string(m_str, '[', ',', ']'); + xy.append_to_string(m_str, '[', ',', ']', m_precision); m_str += ','; } diff --git a/ThirdParty/osmium/geom/haversine.hpp b/ThirdParty/osmium/geom/haversine.hpp index 5ce09b58d..b8d013492 100644 --- a/ThirdParty/osmium/geom/haversine.hpp +++ b/ThirdParty/osmium/geom/haversine.hpp @@ -1,96 +1,94 @@ -#ifndef OSMIUM_GEOM_HAVERSINE_HPP -#define OSMIUM_GEOM_HAVERSINE_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 -#include - -#include -#include -#include -#include -#include -#include - -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 +#ifndef OSMIUM_GEOM_HAVERSINE_HPP +#define OSMIUM_GEOM_HAVERSINE_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include + +#include +#include +#include +#include + +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 diff --git a/ThirdParty/osmium/geom/mercator_projection.hpp b/ThirdParty/osmium/geom/mercator_projection.hpp index df0d47d8a..d17001717 100644 --- a/ThirdParty/osmium/geom/mercator_projection.hpp +++ b/ThirdParty/osmium/geom/mercator_projection.hpp @@ -46,22 +46,22 @@ namespace osmium { namespace detail { - constexpr double EARTH_RADIUS_FOR_EPSG3857 = 6378137.0; + constexpr double earth_radius_for_epsg3857 = 6378137.0; constexpr inline double lon_to_x(double lon) { - return EARTH_RADIUS_FOR_EPSG3857 * deg_to_rad(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)); + 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; + 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); + return rad_to_deg(2 * std::atan(std::exp(y / earth_radius_for_epsg3857)) - osmium::geom::PI/2); } } // namespace detail @@ -92,7 +92,7 @@ namespace osmium { return Coordinates {detail::lon_to_x(location.lon()), detail::lat_to_y(location.lat())}; } - int epsg() const { + int epsg() const noexcept { return 3857; } diff --git a/ThirdParty/osmium/geom/ogr.hpp b/ThirdParty/osmium/geom/ogr.hpp index c730de85c..2727f2fd8 100644 --- a/ThirdParty/osmium/geom/ogr.hpp +++ b/ThirdParty/osmium/geom/ogr.hpp @@ -37,11 +37,16 @@ DEALINGS IN THE SOFTWARE. #define OSMIUM_LINK_WITH_LIBS_OGR `gdal-config --libs` #include +#include #include #include #pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdocumentation-unknown-command" +#ifdef __clang__ +# pragma GCC diagnostic ignored "-Wdocumentation-unknown-command" +#endif +#pragma GCC diagnostic ignored "-Wfloat-equal" +#pragma GCC diagnostic ignored "-Wpadded" # include #pragma GCC diagnostic pop @@ -96,6 +101,23 @@ namespace osmium { return std::move(m_linestring); } + /* Polygon */ + + void polygon_start() { + m_ring = std::unique_ptr(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 polygon = std::unique_ptr(new OGRPolygon()); + polygon->addRingDirectly(m_ring.release()); + return polygon; + } + /* MultiPolygon */ void multipolygon_start() { diff --git a/ThirdParty/osmium/geom/projection.hpp b/ThirdParty/osmium/geom/projection.hpp index 2f9849fe7..72ff945e9 100644 --- a/ThirdParty/osmium/geom/projection.hpp +++ b/ThirdParty/osmium/geom/projection.hpp @@ -57,7 +57,7 @@ namespace osmium { void operator()(void* crs) { pj_free(crs); } - }; + }; // struct ProjCRSDeleter std::unique_ptr m_crs; @@ -142,7 +142,7 @@ namespace osmium { } } - int epsg() const { + int epsg() const noexcept { return m_epsg; } diff --git a/ThirdParty/osmium/geom/util.hpp b/ThirdParty/osmium/geom/util.hpp index 25ea74626..1f1a50dc8 100644 --- a/ThirdParty/osmium/geom/util.hpp +++ b/ThirdParty/osmium/geom/util.hpp @@ -1,71 +1,75 @@ -#ifndef OSMIUM_GEOM_UTIL_HPP -#define OSMIUM_GEOM_UTIL_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 -#include - -namespace osmium { - - 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) { - return degree * (PI / 180.0); - } - - /// Convert angle from radians to degrees. - inline constexpr double rad_to_deg(double radians) { - return radians * (180.0 / PI); - } - - } // namespace geom - -} // namespace osmium - -#endif // OSMIUM_GEOM_UTIL_HPP +#ifndef OSMIUM_GEOM_UTIL_HPP +#define OSMIUM_GEOM_UTIL_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include + +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 diff --git a/ThirdParty/osmium/geom/wkb.hpp b/ThirdParty/osmium/geom/wkb.hpp index ac4c47bc8..0748ede54 100644 --- a/ThirdParty/osmium/geom/wkb.hpp +++ b/ThirdParty/osmium/geom/wkb.hpp @@ -38,8 +38,18 @@ DEALINGS IN THE SOFTWARE. #include #include +// Windows is only available for little endian architectures +// http://stackoverflow.com/questions/6449468/can-i-safely-assume-that-windows-installations-will-always-be-little-endian +#if !defined(_WIN32) && !defined(__APPLE__) +# include +#else +# define __LITTLE_ENDIAN 1234 +# define __BYTE_ORDER __LITTLE_ENDIAN +#endif + #include #include +#include namespace osmium { @@ -48,12 +58,12 @@ namespace osmium { 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 { @@ -99,7 +109,7 @@ namespace osmium { // SRID-presence flag (EWKB) wkbSRID = 0x20000000 - }; + }; // enum wkbGeometryType /** * Byte order marker in WKB geometry. @@ -107,7 +117,7 @@ namespace osmium { 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}; @@ -122,7 +132,11 @@ namespace osmium { 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); @@ -136,8 +150,9 @@ namespace osmium { return offset; } - void set_size(const size_t offset, const uint32_t size) { - memcpy(&m_data[offset], &size, sizeof(uint32_t)); + void set_size(const size_t offset, const size_t size) { + const uint32_t s = static_cast_with_assert(size); + memcpy(&m_data[offset], &s, sizeof(uint32_t)); } public: diff --git a/ThirdParty/osmium/geom/wkt.hpp b/ThirdParty/osmium/geom/wkt.hpp index dd12ad34e..0ef304a86 100644 --- a/ThirdParty/osmium/geom/wkt.hpp +++ b/ThirdParty/osmium/geom/wkt.hpp @@ -34,6 +34,7 @@ DEALINGS IN THE SOFTWARE. */ #include +#include #include #include @@ -49,6 +50,7 @@ namespace osmium { class WKTFactoryImpl { std::string m_str; + int m_precision; public: @@ -58,11 +60,15 @@ namespace osmium { 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, '(', ' ', ')'); + xy.append_to_string(str, '(', ' ', ')', m_precision); return str; } @@ -73,7 +79,7 @@ namespace osmium { } void linestring_add_location(const osmium::geom::Coordinates& xy) { - xy.append_to_string(m_str, ' '); + xy.append_to_string(m_str, ' ', m_precision); m_str += ','; } @@ -118,7 +124,7 @@ namespace osmium { } void multipolygon_add_location(const osmium::geom::Coordinates& xy) { - xy.append_to_string(m_str, ' '); + xy.append_to_string(m_str, ' ', m_precision); m_str += ','; } diff --git a/ThirdParty/osmium/handler/chain.hpp b/ThirdParty/osmium/handler/chain.hpp index a7bf10e9a..868632d7e 100644 --- a/ThirdParty/osmium/handler/chain.hpp +++ b/ThirdParty/osmium/handler/chain.hpp @@ -1,128 +1,128 @@ -#ifndef OSMIUM_HANDLER_CHAIN_HPP -#define OSMIUM_HANDLER_CHAIN_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2014 Jochen Topf 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 - -#include - -#define OSMIUM_CHAIN_HANDLER_CALL(_func_, _type_) \ - template \ - struct call_ ## _func_ { \ - void operator()(THandlers& handlers, osmium::_type_& object) { \ - std::get(handlers)._func_(object); \ - call_ ## _func_()(handlers, object); \ - } \ - }; \ - template \ - struct call_ ## _func_ { \ - 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 - class ChainHandler : public osmium::handler::Handler { - - typedef std::tuple handlers_type; - handlers_type m_handlers; - - template - struct call_flush { - void operator()(THandlers& handlers) { - std::get(handlers).flush(); - call_flush()(handlers); - } - }; - - template - struct call_flush { - void operator()(THandlers&) {} - }; - - 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 +#ifndef OSMIUM_HANDLER_CHAIN_HPP +#define OSMIUM_HANDLER_CHAIN_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2014 Jochen Topf 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 + +#include + +#define OSMIUM_CHAIN_HANDLER_CALL(_func_, _type_) \ + template \ + struct call_ ## _func_ { \ + void operator()(THandlers& handlers, osmium::_type_& object) { \ + std::get(handlers)._func_(object); \ + call_ ## _func_()(handlers, object); \ + } \ + }; \ + template \ + struct call_ ## _func_ { \ + 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 + class ChainHandler : public osmium::handler::Handler { + + typedef std::tuple handlers_type; + handlers_type m_handlers; + + template + struct call_flush { + void operator()(THandlers& handlers) { + std::get(handlers).flush(); + call_flush()(handlers); + } + }; // struct call_flush + + template + struct call_flush { + 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 diff --git a/ThirdParty/osmium/handler/dump.hpp b/ThirdParty/osmium/handler/dump.hpp index 63c66e39e..e62c4b071 100644 --- a/ThirdParty/osmium/handler/dump.hpp +++ b/ThirdParty/osmium/handler/dump.hpp @@ -1,294 +1,294 @@ -#ifndef OSMIUM_HANDLER_DUMP_HPP -#define OSMIUM_HANDLER_DUMP_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -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 +#ifndef OSMIUM_HANDLER_DUMP_HPP +#define OSMIUM_HANDLER_DUMP_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +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 diff --git a/ThirdParty/osmium/handler/node_locations_for_ways.hpp b/ThirdParty/osmium/handler/node_locations_for_ways.hpp index 695eae010..8ece3d9f6 100644 --- a/ThirdParty/osmium/handler/node_locations_for_ways.hpp +++ b/ThirdParty/osmium/handler/node_locations_for_ways.hpp @@ -1,148 +1,170 @@ -#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,2014 Jochen Topf 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 -#include -#include -#include -#include -#include -#include -#include - -namespace osmium { - - namespace handler { - - typedef osmium::index::map::Dummy 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 - class NodeLocationsForWays : public osmium::handler::Handler { - - /// 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() 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(id, node.location()); - } else { - m_storage_neg.set(-id, node.location()); - } - } - - /** - * Get location of node with given id. - */ - osmium::Location get_node_location(const osmium::object_id_type id) const { - return id >= 0 ? m_storage_pos.get(id) : m_storage_neg.get(-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.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("not found"); - } - } - - }; // class NodeLocationsForWays - - } // namespace handler - -} // namespace osmium - -#endif // OSMIUM_HANDLER_NODE_LOCATIONS_FOR_WAYS_HPP +#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,2014 Jochen Topf 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 + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace osmium { + + namespace handler { + + typedef osmium::index::map::Dummy 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 + class NodeLocationsForWays : public osmium::handler::Handler { + + static_assert(std::is_base_of, TStoragePosIDs>::value, + "Index class must be derived from osmium::index::map::Map"); + + static_assert(std::is_base_of, TStorageNegIDs>::value, + "Index class must be derived from osmium::index::map::Map"); + + /// 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() 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( id), node.location()); + } else { + m_storage_neg.set(static_cast(-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( id)); + } else { + return m_storage_neg.get(static_cast(-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 diff --git a/ThirdParty/osmium/index/detail/mmap_vector_base.hpp b/ThirdParty/osmium/index/detail/mmap_vector_base.hpp index 7ff4af2ba..fc96b271a 100644 --- a/ThirdParty/osmium/index/detail/mmap_vector_base.hpp +++ b/ThirdParty/osmium/index/detail/mmap_vector_base.hpp @@ -1,183 +1,183 @@ -#ifndef OSMIUM_DETAIL_MMAP_VECTOR_BASE_HPP -#define OSMIUM_DETAIL_MMAP_VECTOR_BASE_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 -#include -#include - -#include - -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. This class can not be used - * on it's own. Use the derived classes mmap_vector_anon or - * mmap_vector_file. - */ - template class TDerived> - class mmap_vector_base { - - protected: - - int m_fd; - size_t m_capacity; - size_t m_size; - T* m_data; - - explicit mmap_vector_base(int fd, size_t capacity, size_t size, T* data) : - m_fd(fd), - m_capacity(capacity), - m_size(size), - m_data(data) { - } - - explicit mmap_vector_base(int fd, size_t capacity, size_t size) : - m_fd(fd), - m_capacity(capacity), - m_size(size), - m_data(osmium::detail::typed_mmap::grow_and_map(capacity, m_fd)) { - } - - void data(T* data) { - m_data = data; - } - - public: - - 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; - - ~mmap_vector_base() { - osmium::detail::typed_mmap::unmap(m_data, m_capacity); - } - - size_t capacity() const { - return m_capacity; - } - - size_t size() const { - return m_size; - } - - bool empty() const { - return m_size == 0; - } - - const T* data() const { - return m_data; - } - - T* data() { - return m_data; - } - - T& operator[](size_t n) { - return m_data[n]; - } - - T at(size_t n) const { - if (n >= m_size) { - throw std::out_of_range("out of range"); - } - return m_data[n]; - } - - void clear() { - m_size = 0; - } - - void shrink_to_fit() { - // XXX do something here - } - - void push_back(const T& value) { - if (m_size >= m_capacity) { - resize(m_size+1); - } - m_data[m_size] = value; - ++m_size; - } - - void resize(size_t new_size) { - if (new_size > this->capacity()) { - static_cast*>(this)->reserve(new_size + osmium::detail::mmap_vector_size_increment); - } - if (new_size > this->size()) { - new (this->data() + this->size()) T[new_size - this->size()]; - } - this->m_size = new_size; - } - - iterator begin() { - return m_data; - } - - iterator end() { - return m_data + m_size; - } - - const_iterator begin() const { - return m_data; - } - - const_iterator end() const { - return m_data + m_size; - } - - const_iterator cbegin() { - return m_data; - } - - const_iterator cend() { - return m_data + m_size; - } - - }; // class mmap_vector_base - - } // namespace detail - -} // namespace osmium - -#endif // OSMIUM_DETAIL_MMAP_VECTOR_BASE_HPP +#ifndef OSMIUM_DETAIL_MMAP_VECTOR_BASE_HPP +#define OSMIUM_DETAIL_MMAP_VECTOR_BASE_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include + +#include + +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. This class can not be used + * on it's own. Use the derived classes mmap_vector_anon or + * mmap_vector_file. + */ + template class TDerived> + class mmap_vector_base { + + protected: + + int m_fd; + size_t m_capacity; + size_t m_size; + T* m_data; + + explicit mmap_vector_base(int fd, size_t capacity, size_t size, T* data) noexcept : + m_fd(fd), + m_capacity(capacity), + m_size(size), + m_data(data) { + } + + explicit mmap_vector_base(int fd, size_t capacity, size_t size) : + m_fd(fd), + m_capacity(capacity), + m_size(size), + m_data(osmium::detail::typed_mmap::grow_and_map(capacity, m_fd)) { + } + + void data(T* data) { + m_data = data; + } + + public: + + 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; + + ~mmap_vector_base() { + osmium::detail::typed_mmap::unmap(m_data, m_capacity); + } + + size_t capacity() const noexcept { + return m_capacity; + } + + size_t size() const noexcept { + return m_size; + } + + bool empty() const noexcept { + return m_size == 0; + } + + const T* data() const noexcept { + return m_data; + } + + T* data() noexcept { + return m_data; + } + + T& operator[](size_t n) { + return m_data[n]; + } + + T at(size_t n) const { + if (n >= m_size) { + throw std::out_of_range("out of range"); + } + return m_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 >= m_capacity) { + resize(m_size+1); + } + m_data[m_size] = value; + ++m_size; + } + + void resize(size_t new_size) { + if (new_size > capacity()) { + static_cast*>(this)->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 m_data; + } + + iterator end() noexcept { + return m_data + m_size; + } + + const_iterator begin() const noexcept { + return m_data; + } + + const_iterator end() const noexcept { + return m_data + m_size; + } + + const_iterator cbegin() noexcept { + return m_data; + } + + const_iterator cend() noexcept { + return m_data + m_size; + } + + }; // class mmap_vector_base + + } // namespace detail + +} // namespace osmium + +#endif // OSMIUM_DETAIL_MMAP_VECTOR_BASE_HPP diff --git a/ThirdParty/osmium/index/detail/mmap_vector_file.hpp b/ThirdParty/osmium/index/detail/mmap_vector_file.hpp index fe2f98a9e..ca8f0ebfa 100644 --- a/ThirdParty/osmium/index/detail/mmap_vector_file.hpp +++ b/ThirdParty/osmium/index/detail/mmap_vector_file.hpp @@ -1,83 +1,82 @@ -#ifndef OSMIUM_DETAIL_MMAP_VECTOR_FILE_HPP -#define OSMIUM_DETAIL_MMAP_VECTOR_FILE_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 - -#include -#include -#include - -namespace osmium { - - namespace detail { - - /** - * This class looks and behaves like STL vector, but mmap's a file internally. - */ - template - class mmap_vector_file : public mmap_vector_base { - - public: - - explicit mmap_vector_file() : - mmap_vector_base( - osmium::detail::create_tmp_file(), - osmium::detail::mmap_vector_size_increment, - 0) { - } - - explicit mmap_vector_file(int fd) : - mmap_vector_base( - fd, - osmium::detail::typed_mmap::file_size(fd) == 0 ? osmium::detail::mmap_vector_size_increment : osmium::detail::typed_mmap::file_size(fd), - osmium::detail::typed_mmap::file_size(fd)) { - } - - void reserve(size_t new_capacity) { - if (new_capacity > this->capacity()) { - osmium::detail::typed_mmap::unmap(this->data(), this->capacity()); - osmium::detail::typed_mmap::grow_file(new_capacity, this->m_fd); - osmium::detail::typed_mmap::map(new_capacity, this->m_fd); - this->m_capacity = new_capacity; - } - } - - }; // class mmap_vector_file - - } // namespace detail - -} // namespace osmium - -#endif // OSMIUM_DETAIL_MMAP_VECTOR_FILE_HPP +#ifndef OSMIUM_DETAIL_MMAP_VECTOR_FILE_HPP +#define OSMIUM_DETAIL_MMAP_VECTOR_FILE_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 + +#include +#include +#include + +namespace osmium { + + namespace detail { + + /** + * This class looks and behaves like STL vector, but mmap's a file internally. + */ + template + class mmap_vector_file : public mmap_vector_base { + + public: + + explicit mmap_vector_file() : + mmap_vector_base( + osmium::detail::create_tmp_file(), + osmium::detail::mmap_vector_size_increment, + 0) { + } + + explicit mmap_vector_file(int fd) : + mmap_vector_base( + fd, + osmium::detail::typed_mmap::file_size(fd) == 0 ? osmium::detail::mmap_vector_size_increment : osmium::detail::typed_mmap::file_size(fd), + osmium::detail::typed_mmap::file_size(fd)) { + } + + void reserve(size_t new_capacity) { + if (new_capacity > this->capacity()) { + osmium::detail::typed_mmap::unmap(this->data(), this->capacity()); + this->data(osmium::detail::typed_mmap::grow_and_map(new_capacity, this->m_fd)); + this->m_capacity = new_capacity; + } + } + + }; // class mmap_vector_file + + } // namespace detail + +} // namespace osmium + +#endif // OSMIUM_DETAIL_MMAP_VECTOR_FILE_HPP diff --git a/ThirdParty/osmium/index/detail/tmpfile.hpp b/ThirdParty/osmium/index/detail/tmpfile.hpp index 50c9cc9a5..3d00c5017 100644 --- a/ThirdParty/osmium/index/detail/tmpfile.hpp +++ b/ThirdParty/osmium/index/detail/tmpfile.hpp @@ -44,8 +44,8 @@ namespace osmium { /** * Create and open a temporary file. It is removed after opening. * - * @return File descriptor of temporary file. - * @exception std::system_error if something went wrong. + * @returns File descriptor of temporary file. + * @throws std::system_error if something went wrong. */ inline int create_tmp_file() { FILE* file = ::tmpfile(); diff --git a/ThirdParty/osmium/index/detail/typed_mmap.hpp b/ThirdParty/osmium/index/detail/typed_mmap.hpp index d064da2be..8a952a4e0 100644 --- a/ThirdParty/osmium/index/detail/typed_mmap.hpp +++ b/ThirdParty/osmium/index/detail/typed_mmap.hpp @@ -38,18 +38,18 @@ DEALINGS IN THE SOFTWARE. #include #include -#ifndef WIN32 +#include + +#ifndef _WIN32 # include #else # include #endif -#include - -#ifdef _MSC_VER -# define ftruncate _chsize -#else +#ifndef _MSC_VER # include +#else +# define ftruncate _chsize #endif // for bsd systems @@ -57,6 +57,8 @@ DEALINGS IN THE SOFTWARE. # define MAP_ANONYMOUS MAP_ANON #endif +#include + namespace osmium { /** @@ -89,8 +91,8 @@ namespace osmium { * Note that no constructor is called for any of the objects in this memory! * * @param size Number of objects of type T that should fit into this memory - * @return Pointer to mapped memory - * @exception std::system_error If mmap(2) failed + * @returns Pointer to mapped memory + * @throws std::system_error If mmap(2) failed */ static T* map(size_t size) { void* addr = ::mmap(nullptr, sizeof(T) * size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); @@ -113,8 +115,8 @@ namespace osmium { * @param size Number of objects of type T that should fit into this memory * @param fd File descriptor * @param write True if data should be writable - * @return Pointer to mapped memory - * @exception std::system_error If mmap(2) failed + * @returns Pointer to mapped memory + * @throws std::system_error If mmap(2) failed */ static T* map(size_t size, int fd, bool write = false) { int prot = PROT_READ; @@ -141,7 +143,7 @@ namespace osmium { * @param data Pointer to current mapping (as returned by typed_mmap()) * @param old_size Number of objects currently stored in this memory * @param new_size Number of objects we want to have space for - * @exception std::system_error If mremap(2) call failed + * @throws std::system_error If mremap(2) call failed */ static T* remap(T* data, size_t old_size, size_t new_size) { void* addr = ::mremap(reinterpret_cast(data), sizeof(T) * old_size, sizeof(T) * new_size, MREMAP_MAYMOVE); @@ -162,7 +164,7 @@ namespace osmium { * * @param data Pointer to the data * @param size Number of objects of type T stored - * @exception std::system_error If munmap(2) call failed + * @throws std::system_error If munmap(2) call failed */ static void unmap(T* data, size_t size) { if (::munmap(reinterpret_cast(data), sizeof(T) * size) != 0) { @@ -174,19 +176,19 @@ namespace osmium { * Get number of objects of type T that would fit into a file. * * @param fd File descriptor - * @return Number of objects of type T in this file - * @exception std::system_error If fstat(2) call failed - * @exception std::length_error If size of the file isn't a multiple of sizeof(T) + * @returns Number of objects of type T in this file + * @throws std::system_error If fstat(2) call failed + * @throws std::length_error If size of the file isn't a multiple of sizeof(T) */ static size_t file_size(int fd) { struct stat s; if (fstat(fd, &s) < 0) { throw std::system_error(errno, std::system_category(), "fstat failed"); } - if (s.st_size % sizeof(T) != 0) { + if (static_cast(s.st_size) % sizeof(T) != 0) { throw std::length_error("file size has to be multiple of object size"); } - return s.st_size / sizeof(T); + return static_cast(s.st_size) / sizeof(T); } /** @@ -196,11 +198,11 @@ namespace osmium { * * @param new_size Number of objects of type T that should fit into this file * @param fd File descriptor - * @exception std::system_error If ftruncate(2) call failed + * @throws std::system_error If ftruncate(2) call failed */ static void grow_file(size_t new_size, int fd) { if (file_size(fd) < new_size) { - if (::ftruncate(fd, sizeof(T) * new_size) < 0) { + if (::ftruncate(fd, static_cast_with_assert(sizeof(T) * new_size)) < 0) { throw std::system_error(errno, std::system_category(), "ftruncate failed"); } } @@ -211,7 +213,7 @@ namespace osmium { * * @param size Number of objects of type T that should fit into this file * @param fd File descriptor - * @exception Errors thrown by grow_file() or map() + * @throws Errors thrown by grow_file() or map() */ static T* grow_and_map(size_t size, int fd) { grow_file(size, fd); diff --git a/ThirdParty/osmium/index/map.hpp b/ThirdParty/osmium/index/map.hpp index df865c727..92b880f47 100644 --- a/ThirdParty/osmium/index/map.hpp +++ b/ThirdParty/osmium/index/map.hpp @@ -1,156 +1,155 @@ -#ifndef OSMIUM_INDEX_MAP_HPP -#define OSMIUM_INDEX_MAP_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 -#include - -#include // IWYU pragma: export - -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 - class Map { - - static_assert(std::is_integral::value && std::is_unsigned::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; - -// workaround for a bug in GCC 4.7 -#if __GNUC__ == 4 && __GNUC_MINOR__ < 8 - virtual ~Map() {} -#else - virtual ~Map() = default; -#endif - - 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 - } - - }; // class Map - - } // namespace map - - } // namespace index - -} // namespace osmium - -#endif // OSMIUM_INDEX_MAP_HPP +#ifndef OSMIUM_INDEX_MAP_HPP +#define OSMIUM_INDEX_MAP_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include + +#include // IWYU pragma: export + +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 + class Map { + + static_assert(std::is_integral::value && std::is_unsigned::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() = 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 + } + + virtual void dump_as_list(int /*fd*/) const { + std::runtime_error("can't dump as list"); + } + + }; // class Map + + } // namespace map + + } // namespace index + +} // namespace osmium + +#endif // OSMIUM_INDEX_MAP_HPP diff --git a/ThirdParty/osmium/index/map/sparse_table.hpp b/ThirdParty/osmium/index/map/sparse_table.hpp index 21eb6681d..704e33e21 100644 --- a/ThirdParty/osmium/index/map/sparse_table.hpp +++ b/ThirdParty/osmium/index/map/sparse_table.hpp @@ -1,140 +1,140 @@ -#ifndef OSMIUM_INDEX_MAP_SPARSE_TABLE_HPP -#define OSMIUM_INDEX_MAP_SPARSE_TABLE_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 -#include -#include -#include - -#include - -#include -#include - -namespace osmium { - - namespace index { - - namespace map { - - /** - * The SparseTable index stores elements in a Google sparsetable, - * a data structure that can hold sparsly filled tables in a - * very 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 - class SparseTable : public osmium::index::map::Map { - - TId m_grow_size; - - google::sparsetable m_elements; - - static_assert(sizeof(typename google::sparsetable::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 SparseTable(const TId grow_size=10000) : - m_grow_size(grow_size), - m_elements(grow_size) { - } - - ~SparseTable() override final = default; - - void set(const TId id, const TValue value) override final { - if (id >= m_elements.size()) { - m_elements.resize(id + m_grow_size); - } - m_elements[id] = value; - } - - const TValue get(const TId id) const override final { - if (id >= m_elements.size()) { - not_found_error(id); - } - if (m_elements[id] == osmium::index::empty_value()) { - not_found_error(id); - } - return m_elements[id]; - } - - size_t size() const override final { - return m_elements.size(); - } - - size_t used_memory() const override 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() override final { - m_elements.clear(); - } - - void dump_as_list(const int fd) const { - std::vector> v; - int n=0; - for (const TValue value : m_elements) { - if (value != osmium::index::empty_value()) { - v.emplace_back(n, value); - } - ++n; - } - osmium::io::detail::reliable_write(fd, reinterpret_cast(v.data()), sizeof(std::pair) * v.size()); - } - - }; // class SparseTable - - } // namespace map - - } // namespace index - -} // namespace osmium - -#endif // OSMIUM_INDEX_BYID_SPARSE_TABLE_HPP +#ifndef OSMIUM_INDEX_MAP_SPARSE_TABLE_HPP +#define OSMIUM_INDEX_MAP_SPARSE_TABLE_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include + +#include + +#include +#include + +namespace osmium { + + namespace index { + + namespace map { + + /** + * The SparseTable index stores elements in a Google sparsetable, + * a data structure that can hold sparsly filled tables in a + * very 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 + class SparseTable : public osmium::index::map::Map { + + TId m_grow_size; + + google::sparsetable m_elements; + + static_assert(sizeof(typename google::sparsetable::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 SparseTable(const TId grow_size=10000) : + m_grow_size(grow_size), + m_elements(grow_size) { + } + + ~SparseTable() override final = default; + + void set(const TId id, const TValue value) override final { + if (id >= m_elements.size()) { + m_elements.resize(id + m_grow_size); + } + m_elements[id] = value; + } + + const TValue get(const TId id) const override final { + if (id >= m_elements.size()) { + not_found_error(id); + } + if (m_elements[id] == osmium::index::empty_value()) { + not_found_error(id); + } + return m_elements[id]; + } + + size_t size() const override final { + return m_elements.size(); + } + + size_t used_memory() const override 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() override final { + m_elements.clear(); + } + + void dump_as_list(const int fd) const override final { + std::vector> v; + int n=0; + for (const TValue value : m_elements) { + if (value != osmium::index::empty_value()) { + v.emplace_back(n, value); + } + ++n; + } + osmium::io::detail::reliable_write(fd, reinterpret_cast(v.data()), sizeof(std::pair) * v.size()); + } + + }; // class SparseTable + + } // namespace map + + } // namespace index + +} // namespace osmium + +#endif // OSMIUM_INDEX_BYID_SPARSE_TABLE_HPP diff --git a/ThirdParty/osmium/index/map/stl_map.hpp b/ThirdParty/osmium/index/map/stl_map.hpp index 08458d55e..d2781a7e1 100644 --- a/ThirdParty/osmium/index/map/stl_map.hpp +++ b/ThirdParty/osmium/index/map/stl_map.hpp @@ -1,112 +1,112 @@ -#ifndef OSMIUM_INDEX_MAP_STL_MAP_HPP -#define OSMIUM_INDEX_MAP_STL_MAP_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 -#include -#include -#include -#include -#include - -#include -#include - -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 - class StlMap : public osmium::index::map::Map { - - // 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 m_elements; - - public: - - StlMap() = default; - - ~StlMap() override final = default; - - void set(const TId id, const TValue value) override final { - m_elements[id] = value; - } - - const TValue get(const TId id) const override final { - try { - return m_elements.at(id); - } catch (std::out_of_range&) { - not_found_error(id); - } - } - - size_t size() const override final { - return m_elements.size(); - } - - size_t used_memory() const override final { - return element_size * m_elements.size(); - } - - void clear() override final { - m_elements.clear(); - } - - void dump_as_list(const int fd) const { - typedef typename std::map::value_type t; - std::vector v; - std::copy(m_elements.begin(), m_elements.end(), std::back_inserter(v)); - osmium::io::detail::reliable_write(fd, reinterpret_cast(v.data()), sizeof(t) * v.size()); - } - - }; // class StlMap - - } // namespace map - - } // namespace index - -} // namespace osmium - -#endif // OSMIUM_INDEX_MAP_STL_MAP_HPP +#ifndef OSMIUM_INDEX_MAP_STL_MAP_HPP +#define OSMIUM_INDEX_MAP_STL_MAP_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include +#include +#include + +#include +#include + +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 + class StlMap : public osmium::index::map::Map { + + // 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 m_elements; + + public: + + StlMap() = default; + + ~StlMap() override final = default; + + void set(const TId id, const TValue value) override final { + m_elements[id] = value; + } + + const TValue get(const TId id) const override final { + try { + return m_elements.at(id); + } catch (std::out_of_range&) { + not_found_error(id); + } + } + + size_t size() const override final { + return m_elements.size(); + } + + size_t used_memory() const override final { + return element_size * m_elements.size(); + } + + void clear() override final { + m_elements.clear(); + } + + void dump_as_list(const int fd) const override final { + typedef typename std::map::value_type t; + std::vector v; + std::copy(m_elements.begin(), m_elements.end(), std::back_inserter(v)); + osmium::io::detail::reliable_write(fd, reinterpret_cast(v.data()), sizeof(t) * v.size()); + } + + }; // class StlMap + + } // namespace map + + } // namespace index + +} // namespace osmium + +#endif // OSMIUM_INDEX_MAP_STL_MAP_HPP diff --git a/ThirdParty/osmium/index/map/vector.hpp b/ThirdParty/osmium/index/map/vector.hpp index 3e4890024..7e47ccfba 100644 --- a/ThirdParty/osmium/index/map/vector.hpp +++ b/ThirdParty/osmium/index/map/vector.hpp @@ -1,208 +1,208 @@ -#ifndef OSMIUM_INDEX_MAP_VECTOR_HPP -#define OSMIUM_INDEX_MAP_VECTOR_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 -#include -#include -#include - -#include -#include - -namespace osmium { - - namespace index { - - namespace map { - - template - class VectorBasedDenseMap : public Map { - - TVector m_vector; - - public: - - VectorBasedDenseMap() : - m_vector() { - } - - explicit VectorBasedDenseMap(int fd) : - m_vector(fd) { - } - - ~VectorBasedDenseMap() {} - - void reserve(const size_t size) override final { - m_vector.reserve(size); - } - - void set(const TId id, const TValue value) override final { - if (size() <= id) { - m_vector.resize(id+1); - } - m_vector[id] = value; - } - - const TValue get(const TId id) const override final { - try { - const TValue& value = m_vector.at(id); - if (value == osmium::index::empty_value()) { - not_found_error(id); - } - return value; - } catch (std::out_of_range&) { - not_found_error(id); - } - } - - size_t size() const override final { - return m_vector.size(); - } - - size_t used_memory() const override final { - return sizeof(TValue) * size(); - } - - void clear() override final { - m_vector.clear(); - m_vector.shrink_to_fit(); - } - - }; // class VectorBasedDenseMap - - - template class TVector> - class VectorBasedSparseMap : public Map { - - public: - - typedef typename std::pair element_type; - typedef TVector 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() { - } - - VectorBasedSparseMap(int fd) : - m_vector(fd) { - } - - ~VectorBasedSparseMap() override final = default; - - void set(const TId id, const TValue value) override final { - m_vector.push_back(element_type(id, value)); - } - - const TValue get(const TId id) const override final { - const element_type element { - id, - osmium::index::empty_value() - }; - 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 override final { - return m_vector.size(); - } - - size_t byte_size() const { - return m_vector.size() * sizeof(element_type); - } - - size_t used_memory() const override final { - return sizeof(element_type) * size(); - } - - void clear() override final { - m_vector.clear(); - m_vector.shrink_to_fit(); - } - - void sort() override final { - std::sort(m_vector.begin(), m_vector.end()); - } - - void dump_as_list(int fd) const { - osmium::io::detail::reliable_write(fd, reinterpret_cast(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_MAP_VECTOR_HPP +#ifndef OSMIUM_INDEX_MAP_VECTOR_HPP +#define OSMIUM_INDEX_MAP_VECTOR_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include + +#include +#include + +namespace osmium { + + namespace index { + + namespace map { + + template + class VectorBasedDenseMap : public Map { + + TVector m_vector; + + public: + + VectorBasedDenseMap() : + m_vector() { + } + + explicit VectorBasedDenseMap(int fd) : + m_vector(fd) { + } + + ~VectorBasedDenseMap() {} + + void reserve(const size_t size) override final { + m_vector.reserve(size); + } + + void set(const TId id, const TValue value) override final { + if (size() <= id) { + m_vector.resize(id+1); + } + m_vector[id] = value; + } + + const TValue get(const TId id) const override final { + try { + const TValue& value = m_vector.at(id); + if (value == osmium::index::empty_value()) { + not_found_error(id); + } + return value; + } catch (std::out_of_range&) { + not_found_error(id); + } + } + + size_t size() const override final { + return m_vector.size(); + } + + size_t used_memory() const override final { + return sizeof(TValue) * size(); + } + + void clear() override final { + m_vector.clear(); + m_vector.shrink_to_fit(); + } + + }; // class VectorBasedDenseMap + + + template class TVector> + class VectorBasedSparseMap : public Map { + + public: + + typedef typename std::pair element_type; + typedef TVector 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() { + } + + VectorBasedSparseMap(int fd) : + m_vector(fd) { + } + + ~VectorBasedSparseMap() override final = default; + + void set(const TId id, const TValue value) override final { + m_vector.push_back(element_type(id, value)); + } + + const TValue get(const TId id) const override final { + const element_type element { + id, + osmium::index::empty_value() + }; + 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 override final { + return m_vector.size(); + } + + size_t byte_size() const { + return m_vector.size() * sizeof(element_type); + } + + size_t used_memory() const override final { + return sizeof(element_type) * size(); + } + + void clear() override final { + m_vector.clear(); + m_vector.shrink_to_fit(); + } + + void sort() override final { + std::sort(m_vector.begin(), m_vector.end()); + } + + void dump_as_list(int fd) const override final { + osmium::io::detail::reliable_write(fd, reinterpret_cast(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_MAP_VECTOR_HPP diff --git a/ThirdParty/osmium/index/multimap.hpp b/ThirdParty/osmium/index/multimap.hpp index bf20dfb26..f76c65ddb 100644 --- a/ThirdParty/osmium/index/multimap.hpp +++ b/ThirdParty/osmium/index/multimap.hpp @@ -1,125 +1,129 @@ -#ifndef OSMIUM_INDEX_MULTIMAP_HPP -#define OSMIUM_INDEX_MULTIMAP_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 -#include -#include - -#include // IWYU pragma: export - -namespace osmium { - - namespace index { - - /** - * @brief Key-value containers with multiple values for an integer key - */ - namespace multimap { - - template - class Multimap { - - static_assert(std::is_integral::value && std::is_unsigned::value, - "TId template parameter for class Multimap must be unsigned integral type"); - - typedef typename std::pair 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 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 - } - - }; // class Multimap - - } // namespace map - - } // namespace index - -} // namespace osmium - -#endif // OSMIUM_INDEX_MULTIMAP_HPP +#ifndef OSMIUM_INDEX_MULTIMAP_HPP +#define OSMIUM_INDEX_MULTIMAP_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include + +#include // IWYU pragma: export + +namespace osmium { + + namespace index { + + /** + * @brief Key-value containers with multiple values for an integer key + */ + namespace multimap { + + template + class Multimap { + + static_assert(std::is_integral::value && std::is_unsigned::value, + "TId template parameter for class Multimap must be unsigned integral type"); + + typedef typename std::pair 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 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(int /*fd*/) const { + std::runtime_error("can't dump as list"); + } + + }; // class Multimap + + } // namespace map + + } // namespace index + +} // namespace osmium + +#endif // OSMIUM_INDEX_MULTIMAP_HPP diff --git a/ThirdParty/osmium/index/multimap/hybrid.hpp b/ThirdParty/osmium/index/multimap/hybrid.hpp index 4214adc4e..abaf31e95 100644 --- a/ThirdParty/osmium/index/multimap/hybrid.hpp +++ b/ThirdParty/osmium/index/multimap/hybrid.hpp @@ -1,199 +1,199 @@ -#ifndef OSMIUM_INDEX_MULTIMAP_HYBRID_HPP -#define OSMIUM_INDEX_MULTIMAP_HYBRID_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 -#include - -#include -#include -#include - -namespace osmium { - - namespace index { - - namespace multimap { - - template - class HybridIterator { - - typedef SparseMultimapMem main_map_type; - typedef StlMultimap extra_map_type; - - typedef typename std::pair 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: - - explicit 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& 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()) { // ignore removed elements - ++m_begin_main; - } - } - return *this; - } - - HybridIterator 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*(); - } - - }; - - template - class Hybrid : public Multimap { - - typedef SparseMultimapMem main_map_type; - typedef StlMultimap extra_map_type; - - main_map_type m_main; - extra_map_type m_extra; - - public: - - typedef HybridIterator iterator; - typedef const HybridIterator const_iterator; - - Hybrid() : - m_main(), - m_extra() { - } - - size_t size() const override final { - return m_main.size() + m_extra.size(); - } - - size_t used_memory() const override 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) override final { - m_extra.set(id, value); - } - - std::pair 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(int fd) { - consolidate(); - m_main.dump_as_list(fd); - } - - void clear() override final { - m_main.clear(); - m_extra.clear(); - } - - void sort() override final { - m_main.sort(); - } - - }; // Hybrid - - } // namespace multimap - - } // namespace index - -} // namespace osmium - -#endif // OSMIUM_INDEX_MULTIMAP_HYBRID_HPP +#ifndef OSMIUM_INDEX_MULTIMAP_HYBRID_HPP +#define OSMIUM_INDEX_MULTIMAP_HYBRID_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include + +#include +#include +#include + +namespace osmium { + + namespace index { + + namespace multimap { + + template + class HybridIterator { + + typedef SparseMultimapMem main_map_type; + typedef StlMultimap extra_map_type; + + typedef typename std::pair 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: + + explicit 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& 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()) { // ignore removed elements + ++m_begin_main; + } + } + return *this; + } + + HybridIterator 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 + class Hybrid : public Multimap { + + typedef SparseMultimapMem main_map_type; + typedef StlMultimap extra_map_type; + + main_map_type m_main; + extra_map_type m_extra; + + public: + + typedef HybridIterator iterator; + typedef const HybridIterator const_iterator; + + Hybrid() : + m_main(), + m_extra() { + } + + size_t size() const override final { + return m_main.size() + m_extra.size(); + } + + size_t used_memory() const override 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) override final { + m_extra.set(id, value); + } + + std::pair 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(int fd) override final { + consolidate(); + m_main.dump_as_list(fd); + } + + void clear() override final { + m_main.clear(); + m_extra.clear(); + } + + void sort() override final { + m_main.sort(); + } + + }; // class Hybrid + + } // namespace multimap + + } // namespace index + +} // namespace osmium + +#endif // OSMIUM_INDEX_MULTIMAP_HYBRID_HPP diff --git a/ThirdParty/osmium/index/multimap/stl_multimap.hpp b/ThirdParty/osmium/index/multimap/stl_multimap.hpp index cd19c1560..3df07abff 100644 --- a/ThirdParty/osmium/index/multimap/stl_multimap.hpp +++ b/ThirdParty/osmium/index/multimap/stl_multimap.hpp @@ -1,151 +1,151 @@ -#ifndef OSMIUM_INDEX_MULTIMAP_STL_MULTIMAP_HPP -#define OSMIUM_INDEX_MULTIMAP_STL_MULTIMAP_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 -#include -#include -#include -#include - -#include -#include - -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 - class StlMultimap : public osmium::index::multimap::Multimap { - - // 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 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 element_type; - - private: - - collection_type m_elements; - - public: - - StlMultimap() = default; - - ~StlMultimap() noexcept override final = default; - - void unsorted_set(const TId id, const TValue value) { - m_elements.emplace(id, value); - } - - void set(const TId id, const TValue value) override final { - m_elements.emplace(id, value); - } - - std::pair get_all(const TId id) { - return m_elements.equal_range(id); - } - - std::pair get_all(const TId id) const { - return m_elements.equal_range(id); - } - - void remove(const TId id, const TValue value) { - std::pair 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 override final { - return m_elements.size(); - } - - size_t used_memory() const override final { - return element_size * m_elements.size(); - } - - void clear() override final { - m_elements.clear(); - } - - void consolidate() { - // intentionally left blank - } - - void dump_as_list(const int fd) const { - std::vector v; - for (const auto& element : m_elements) { - v.emplace_back(element.first, element.second); - } -// std::copy(m_elements.cbegin(), m_elements.cend(), std::back_inserter(v)); - std::sort(v.begin(), v.end()); - osmium::io::detail::reliable_write(fd, reinterpret_cast(v.data()), sizeof(element_type) * v.size()); - } - - }; // class StlMultimap - - } // namespace multimap - - } // namespace index - -} // namespace osmium - -#endif // OSMIUM_INDEX_MULTIMAP_STL_MULTIMAP_HPP +#ifndef OSMIUM_INDEX_MULTIMAP_STL_MULTIMAP_HPP +#define OSMIUM_INDEX_MULTIMAP_STL_MULTIMAP_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include +#include + +#include +#include + +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 + class StlMultimap : public osmium::index::multimap::Multimap { + + // 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 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 element_type; + + private: + + collection_type m_elements; + + public: + + StlMultimap() = default; + + ~StlMultimap() noexcept override final = default; + + void unsorted_set(const TId id, const TValue value) { + m_elements.emplace(id, value); + } + + void set(const TId id, const TValue value) override final { + m_elements.emplace(id, value); + } + + std::pair get_all(const TId id) { + return m_elements.equal_range(id); + } + + std::pair get_all(const TId id) const { + return m_elements.equal_range(id); + } + + void remove(const TId id, const TValue value) { + std::pair 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 override final { + return m_elements.size(); + } + + size_t used_memory() const override final { + return element_size * m_elements.size(); + } + + void clear() override final { + m_elements.clear(); + } + + void consolidate() { + // intentionally left blank + } + + void dump_as_list(const int fd) const override final { + std::vector v; + for (const auto& element : m_elements) { + v.emplace_back(element.first, element.second); + } +// std::copy(m_elements.cbegin(), m_elements.cend(), std::back_inserter(v)); + std::sort(v.begin(), v.end()); + osmium::io::detail::reliable_write(fd, reinterpret_cast(v.data()), sizeof(element_type) * v.size()); + } + + }; // class StlMultimap + + } // namespace multimap + + } // namespace index + +} // namespace osmium + +#endif // OSMIUM_INDEX_MULTIMAP_STL_MULTIMAP_HPP diff --git a/ThirdParty/osmium/index/multimap/vector.hpp b/ThirdParty/osmium/index/multimap/vector.hpp index 1a548a814..b9dae43e5 100644 --- a/ThirdParty/osmium/index/multimap/vector.hpp +++ b/ThirdParty/osmium/index/multimap/vector.hpp @@ -1,141 +1,151 @@ -#ifndef OSMIUM_INDEX_MULTIMAP_VECTOR_HPP -#define OSMIUM_INDEX_MULTIMAP_VECTOR_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 -#include -#include - -#include -#include - -namespace osmium { - - namespace index { - - namespace multimap { - - template class TVector> - class VectorBasedSparseMultimap : public Multimap { - - public: - - typedef typename std::pair element_type; - typedef TVector 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(); - } - - public: - - void set(const TId id, const TValue value) override 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 get_all(const TId id) { - const element_type element { - id, - osmium::index::empty_value() - }; - return std::equal_range(m_vector.begin(), m_vector.end(), element, [](const element_type& a, const element_type& b) { - return a.first < b.first; - }); - } - - size_t size() const override final { - return m_vector.size(); - } - - size_t byte_size() const { - return m_vector.size() * sizeof(element_type); - } - - size_t used_memory() const override final { - return sizeof(element_type) * size(); - } - - void clear() override final { - m_vector.clear(); - m_vector.shrink_to_fit(); - } - - void sort() override 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(int fd) const { - osmium::io::detail::reliable_write(fd, reinterpret_cast(m_vector.data()), byte_size()); - } - - }; // class VectorBasedSparseMultimap - - } // namespace multimap - - } // namespace index - -} // namespace osmium - -#endif // OSMIUM_INDEX_MULTIMAP_VECTOR_HPP +#ifndef OSMIUM_INDEX_MULTIMAP_VECTOR_HPP +#define OSMIUM_INDEX_MULTIMAP_VECTOR_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include + +#include +#include + +namespace osmium { + + namespace index { + + namespace multimap { + + template class TVector> + class VectorBasedSparseMultimap : public Multimap { + + public: + + typedef typename std::pair element_type; + typedef TVector 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(); + } + + public: + + void set(const TId id, const TValue value) override 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 get_all(const TId id) { + const element_type element { + id, + osmium::index::empty_value() + }; + 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 get_all(const TId id) const { + const element_type element { + id, + osmium::index::empty_value() + }; + 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 override final { + return m_vector.size(); + } + + size_t byte_size() const { + return m_vector.size() * sizeof(element_type); + } + + size_t used_memory() const override final { + return sizeof(element_type) * size(); + } + + void clear() override final { + m_vector.clear(); + m_vector.shrink_to_fit(); + } + + void sort() override 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(int fd) const override final { + osmium::io::detail::reliable_write(fd, reinterpret_cast(m_vector.data()), byte_size()); + } + + }; // class VectorBasedSparseMultimap + + } // namespace multimap + + } // namespace index + +} // namespace osmium + +#endif // OSMIUM_INDEX_MULTIMAP_VECTOR_HPP diff --git a/ThirdParty/osmium/io/bzip2_compression.hpp b/ThirdParty/osmium/io/bzip2_compression.hpp index 1b6552528..cbfaf9a5f 100644 --- a/ThirdParty/osmium/io/bzip2_compression.hpp +++ b/ThirdParty/osmium/io/bzip2_compression.hpp @@ -40,22 +40,50 @@ DEALINGS IN THE SOFTWARE. #include #include + #ifndef _MSC_VER # include #endif #include #include +#include #include namespace osmium { + /** + * Exception thrown when there are problems compressing or + * decompressing bzip2 files. + */ + struct bzip2_error : public std::runtime_error { + + int bzip2_error_code; + int system_errno; + + bzip2_error(const std::string& what, int error_code) : + std::runtime_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(const std::string& msg, int error) { - throw std::runtime_error("bzip2 error: " + msg + ": " + std::to_string(error)); + 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 @@ -74,19 +102,19 @@ namespace osmium { m_bzerror(BZ_OK), m_bzfile(::BZ2_bzWriteOpen(&m_bzerror, m_file, 6, 0, 0)) { if (!m_bzfile) { - detail::throw_bzip2_error("write open failed", m_bzerror); + detail::throw_bzip2_error(m_bzfile, "write open failed", m_bzerror); } } ~Bzip2Compressor() override final { - this->close(); + close(); } void write(const std::string& data) override final { int error; - ::BZ2_bzWrite(&error, m_bzfile, const_cast(data.data()), data.size()); + ::BZ2_bzWrite(&error, m_bzfile, const_cast(data.data()), static_cast_with_assert(data.size())); if (error != BZ_OK && error != BZ_STREAM_END) { - detail::throw_bzip2_error("write failed", error); + detail::throw_bzip2_error(m_bzfile, "write failed", error); } } @@ -99,7 +127,7 @@ namespace osmium { fclose(m_file); } if (error != BZ_OK) { - detail::throw_bzip2_error("write close failed", error); + detail::throw_bzip2_error(m_bzfile, "write close failed", error); } } } @@ -121,12 +149,12 @@ namespace osmium { m_bzerror(BZ_OK), m_bzfile(::BZ2_bzReadOpen(&m_bzerror, m_file, 0, 0, nullptr, 0)) { if (!m_bzfile) { - detail::throw_bzip2_error("read open failed", m_bzerror); + detail::throw_bzip2_error(m_bzfile, "read open failed", m_bzerror); } } ~Bzip2Decompressor() override final { - this->close(); + close(); } std::string read() override final { @@ -135,9 +163,9 @@ namespace osmium { } std::string buffer(osmium::io::Decompressor::input_buffer_size, '\0'); int error; - int nread = ::BZ2_bzRead(&error, m_bzfile, const_cast(buffer.data()), buffer.size()); + int nread = ::BZ2_bzRead(&error, m_bzfile, const_cast(buffer.data()), static_cast_with_assert(buffer.size())); if (error != BZ_OK && error != BZ_STREAM_END) { - detail::throw_bzip2_error("read failed", error); + detail::throw_bzip2_error(m_bzfile, "read failed", error); } if (error == BZ_STREAM_END) { void* unused; @@ -145,16 +173,16 @@ namespace osmium { if (! feof(m_file)) { ::BZ2_bzReadGetUnused(&error, m_bzfile, &unused, &nunused); if (error != BZ_OK) { - detail::throw_bzip2_error("get unused failed", error); + detail::throw_bzip2_error(m_bzfile, "get unused failed", error); } std::string unused_data(static_cast(unused), static_cast(nunused)); ::BZ2_bzReadClose(&error, m_bzfile); if (error != BZ_OK) { - detail::throw_bzip2_error("read close failed", error); + detail::throw_bzip2_error(m_bzfile, "read close failed", error); } - m_bzfile = ::BZ2_bzReadOpen(&error, m_file, 0, 0, const_cast(static_cast(unused_data.data())), unused_data.size()); + m_bzfile = ::BZ2_bzReadOpen(&error, m_file, 0, 0, const_cast(static_cast(unused_data.data())), static_cast_with_assert(unused_data.size())); if (error != BZ_OK) { - detail::throw_bzip2_error("read open failed", error); + detail::throw_bzip2_error(m_bzfile, "read open failed", error); } } else { m_stream_end = true; @@ -173,18 +201,71 @@ namespace osmium { fclose(m_file); } if (error != BZ_OK) { - detail::throw_bzip2_error("read close failed", error); + 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(buffer); + m_bzstream.avail_in = static_cast_with_assert(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() override final { + BZ2_bzDecompressEnd(&m_bzstream); + } + + std::string read() override final { + if (!m_buffer) { + return std::string(); + } + + const size_t buffer_size = 10240; + std::string output(buffer_size, '\0'); + m_bzstream.next_out = const_cast(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(m_bzstream.next_out - output.data())); + return output; + } + + }; // class Bzip2BufferDecompressor + namespace { const bool registered_bzip2_compression = osmium::io::CompressionFactory::instance().register_compression(osmium::io::file_compression::bzip2, [](int fd) { return new osmium::io::Bzip2Compressor(fd); }, - [](int fd) { return new osmium::io::Bzip2Decompressor(fd); } + [](int fd) { return new osmium::io::Bzip2Decompressor(fd); }, + [](const char* buffer, size_t size) { return new osmium::io::Bzip2BufferDecompressor(buffer, size); } ); } // anonymous namespace diff --git a/ThirdParty/osmium/io/compression.hpp b/ThirdParty/osmium/io/compression.hpp index 5ac242ab0..59776408b 100644 --- a/ThirdParty/osmium/io/compression.hpp +++ b/ThirdParty/osmium/io/compression.hpp @@ -40,13 +40,14 @@ DEALINGS IN THE SOFTWARE. #include #include #include -#ifndef _MSC_VER -#include -#else -#include -#endif #include +#ifndef _MSC_VER +# include +#else +# include +#endif + #include #include #include @@ -89,7 +90,8 @@ namespace osmium { virtual std::string read() = 0; - virtual void close() = 0; + virtual void close() { + } }; // class Decompressor @@ -105,11 +107,12 @@ namespace osmium { public: typedef std::function create_compressor_type; - typedef std::function create_decompressor_type; + typedef std::function create_decompressor_type_fd; + typedef std::function create_decompressor_type_buffer; private: - typedef std::map> compression_map_type; + typedef std::map> compression_map_type; compression_map_type m_callbacks; @@ -135,8 +138,13 @@ namespace osmium { return factory; } - bool register_compression(osmium::io::file_compression compression, create_compressor_type create_compressor, create_decompressor_type create_decompressor) { - compression_map_type::value_type cc(compression, std::make_pair(create_compressor, create_decompressor)); + 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; } @@ -144,7 +152,7 @@ namespace osmium { auto it = m_callbacks.find(compression); if (it != m_callbacks.end()) { - return std::unique_ptr((it->second.first)(fd)); + return std::unique_ptr(std::get<0>(it->second)(fd)); } error(compression); @@ -154,7 +162,17 @@ namespace osmium { auto it = m_callbacks.find(compression); if (it != m_callbacks.end()) { - return std::unique_ptr((it->second.second)(fd)); + return std::unique_ptr(std::get<1>(it->second)(fd)); + } + + error(compression); + } + + std::unique_ptr 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(std::get<2>(it->second)(buffer, size)); } error(compression); @@ -174,7 +192,7 @@ namespace osmium { } ~NoCompressor() override final { - this->close(); + close(); } void write(const std::string& data) override final { @@ -193,26 +211,46 @@ namespace osmium { class NoDecompressor : public Decompressor { int m_fd; + const char *m_buffer; + size_t m_buffer_size; public: NoDecompressor(int fd) : Decompressor(), - m_fd(fd) { + 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() override final { - this->close(); + close(); } std::string read() override final { - std::string buffer(osmium::io::Decompressor::input_buffer_size, '\0'); - ssize_t nread = ::read(m_fd, const_cast(buffer.data()), buffer.size()); - if (nread < 0) { - throw std::system_error(errno, std::system_category(), "Read failed"); + if (m_buffer) { + if (m_buffer_size == 0) { + return std::string(); + } + size_t size = m_buffer_size; + m_buffer_size = 0; + return std::string(m_buffer, size); + } else { + std::string buffer(osmium::io::Decompressor::input_buffer_size, '\0'); + ssize_t nread = ::read(m_fd, const_cast(buffer.data()), buffer.size()); + if (nread < 0) { + throw std::system_error(errno, std::system_category(), "Read failed"); + } + buffer.resize(static_cast(nread)); + return buffer; } - buffer.resize(static_cast(nread)); - return buffer; } void close() override final { @@ -228,7 +266,8 @@ namespace osmium { const bool registered_no_compression = osmium::io::CompressionFactory::instance().register_compression(osmium::io::file_compression::none, [](int fd) { return new osmium::io::NoCompressor(fd); }, - [](int fd) { return new osmium::io::NoDecompressor(fd); } + [](int fd) { return new osmium::io::NoDecompressor(fd); }, + [](const char* buffer, size_t size) { return new osmium::io::NoDecompressor(buffer, size); } ); } // anonymous namespace diff --git a/ThirdParty/osmium/io/detail/input_format.hpp b/ThirdParty/osmium/io/detail/input_format.hpp index 13e5ca7d7..f88561b11 100644 --- a/ThirdParty/osmium/io/detail/input_format.hpp +++ b/ThirdParty/osmium/io/detail/input_format.hpp @@ -76,7 +76,7 @@ namespace osmium { m_file(file), m_read_which_entities(read_which_entities), m_input_queue(input_queue) { - m_header.has_multiple_object_versions(m_file.has_multiple_object_versions()); + m_header.set_has_multiple_object_versions(m_file.has_multiple_object_versions()); } InputFormat(const InputFormat&) = delete; diff --git a/ThirdParty/osmium/io/detail/opl_output_format.hpp b/ThirdParty/osmium/io/detail/opl_output_format.hpp index e96d7345c..482aecca5 100644 --- a/ThirdParty/osmium/io/detail/opl_output_format.hpp +++ b/ThirdParty/osmium/io/detail/opl_output_format.hpp @@ -48,12 +48,22 @@ DEALINGS IN THE SOFTWARE. #include +#ifdef __clang__ +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wmissing-noreturn" +# pragma clang diagnostic ignored "-Wsign-conversion" +#endif + #if BOOST_VERSION >= 104800 # include #else # include #endif +#ifdef __clang__ +# pragma clang diagnostic pop +#endif + #include #include #include @@ -95,10 +105,13 @@ namespace osmium { template void output_formatted(const char* format, TArgs&&... args) { +#ifndef NDEBUG + int len = +#endif #ifndef _MSC_VER - int len = snprintf(m_tmp_buffer, tmp_buffer_size, format, std::forward(args)...); + snprintf(m_tmp_buffer, tmp_buffer_size, format, std::forward(args)...); #else - int len = _snprintf(m_tmp_buffer, tmp_buffer_size, format, std::forward(args)...); + _snprintf(m_tmp_buffer, tmp_buffer_size, format, std::forward(args)...); #endif assert(len > 0 && static_cast(len) < tmp_buffer_size); m_out += m_tmp_buffer; @@ -269,7 +282,7 @@ namespace osmium { } void write_buffer(osmium::memory::Buffer&& buffer) override final { - OPLOutputBlock output_block(std::move(buffer)); + osmium::thread::SharedPtrWrapper output_block(std::move(buffer)); m_output_queue.push(osmium::thread::Pool::instance().submit(std::move(output_block))); while (m_output_queue.size() > 10) { std::this_thread::sleep_for(std::chrono::milliseconds(100)); // XXX @@ -287,10 +300,13 @@ namespace osmium { namespace { +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-variable" const bool registered_opl_output = osmium::io::detail::OutputFormatFactory::instance().register_output_format(osmium::io::file_format::opl, [](const osmium::io::File& file, data_queue_type& output_queue) { return new osmium::io::detail::OPLOutputFormat(file, output_queue); }); +#pragma GCC diagnostic pop } // anonymous namespace diff --git a/ThirdParty/osmium/io/detail/pbf.hpp b/ThirdParty/osmium/io/detail/pbf.hpp index cb44bb039..cdd48912e 100644 --- a/ThirdParty/osmium/io/detail/pbf.hpp +++ b/ThirdParty/osmium/io/detail/pbf.hpp @@ -40,7 +40,7 @@ DEALINGS IN THE SOFTWARE. #include // needed for htonl and ntohl -#ifndef WIN32 +#ifndef _WIN32 # include #else # include @@ -50,6 +50,9 @@ DEALINGS IN THE SOFTWARE. namespace osmium { +// avoid g++ false positive +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wreturn-type" inline item_type osmpbf_membertype_to_item_type(const OSMPBF::Relation::MemberType mt) { switch (mt) { case OSMPBF::Relation::NODE: @@ -60,6 +63,7 @@ namespace osmium { return item_type::relation; } } +#pragma GCC diagnostic pop inline OSMPBF::Relation::MemberType item_type_to_osmpbf_membertype(const item_type type) { switch (type) { diff --git a/ThirdParty/osmium/io/detail/pbf_input_format.hpp b/ThirdParty/osmium/io/detail/pbf_input_format.hpp index 36430bea5..bdfa1622d 100644 --- a/ThirdParty/osmium/io/detail/pbf_input_format.hpp +++ b/ThirdParty/osmium/io/detail/pbf_input_format.hpp @@ -33,7 +33,6 @@ DEALINGS IN THE SOFTWARE. */ - #include #include #include @@ -53,6 +52,7 @@ DEALINGS IN THE SOFTWARE. #include #include // IWYU pragma: export #include +#include #include #include #include @@ -65,9 +65,26 @@ DEALINGS IN THE SOFTWARE. #include #include #include +#include namespace osmium { + /** + * Exception thrown when there was a problem with parsing the PBF format of + * a file. + */ + struct pbf_error : public io_error { + + pbf_error(const std::string& what) : + io_error(std::string("PBF error: ") + what) { + } + + pbf_error(const char* what) : + io_error(std::string("PBF error: ") + what) { + } + + }; // struct pbf_error + namespace io { class File; @@ -76,10 +93,10 @@ namespace osmium { class PBFPrimitiveBlockParser { - static constexpr size_t initial_buffer_size = 10 * 1024; + static constexpr size_t initial_buffer_size = 2 * 1024 * 1024; const void* m_data; - const size_t m_size; + const int m_size; const OSMPBF::StringTable* m_stringtable; int64_t m_lon_offset; @@ -99,7 +116,7 @@ namespace osmium { public: - explicit PBFPrimitiveBlockParser(const void* data, const size_t size, osmium::osm_entity_bits::type read_types) : + explicit PBFPrimitiveBlockParser(const void* data, const int size, osmium::osm_entity_bits::type read_types) : m_data(data), m_size(size), m_stringtable(nullptr), @@ -116,7 +133,7 @@ namespace osmium { osmium::memory::Buffer operator()() { OSMPBF::PrimitiveBlock pbf_primitive_block; if (!pbf_primitive_block.ParseFromArray(m_data, m_size)) { - throw std::runtime_error("Failed to parse PrimitiveBlock."); + throw osmium::pbf_error("failed to parse PrimitiveBlock"); } m_stringtable = &pbf_primitive_block.stringtable(); @@ -137,7 +154,7 @@ namespace osmium { } else if (group.nodes_size() != 0) { if (m_read_types & osmium::osm_entity_bits::node) parse_node_group(group); } else { - throw std::runtime_error("Group of unknown type."); + throw osmium::pbf_error("group of unknown type"); } } @@ -150,19 +167,19 @@ namespace osmium { void parse_attributes(TBuilder& builder, const TPBFObject& pbf_object) { auto& object = builder.object(); - object.id(pbf_object.id()); + object.set_id(pbf_object.id()); if (pbf_object.has_info()) { - object.version(pbf_object.info().version()) - .changeset(pbf_object.info().changeset()) - .timestamp(pbf_object.info().timestamp() * m_date_factor) - .uid_from_signed(pbf_object.info().uid()); + object.set_version(static_cast_with_assert(pbf_object.info().version())) + .set_changeset(static_cast_with_assert(pbf_object.info().changeset())) + .set_timestamp(pbf_object.info().timestamp() * m_date_factor) + .set_uid_from_signed(pbf_object.info().uid()); if (pbf_object.info().has_visible()) { - object.visible(pbf_object.info().visible()); + object.set_visible(pbf_object.info().visible()); } - builder.add_user(m_stringtable->s(pbf_object.info().user_sid()).data()); + builder.add_user(m_stringtable->s(static_cast_with_assert(pbf_object.info().user_sid()))); } else { - builder.add_user(""); + builder.add_user("", 1); } } @@ -173,7 +190,7 @@ namespace osmium { parse_attributes(builder, pbf_node); if (builder.object().visible()) { - builder.object().location(osmium::Location( + builder.object().set_location(osmium::Location( (pbf_node.lon() * m_granularity + m_lon_offset) / (OSMPBF::lonlat_resolution / osmium::Location::coordinate_precision), (pbf_node.lat() * m_granularity + m_lat_offset) / (OSMPBF::lonlat_resolution / osmium::Location::coordinate_precision))); } @@ -181,8 +198,8 @@ namespace osmium { if (pbf_node.keys_size() > 0) { osmium::builder::TagListBuilder tl_builder(m_buffer, &builder); for (int tag=0; tag < pbf_node.keys_size(); ++tag) { - tl_builder.add_tag(m_stringtable->s(static_cast(pbf_node.keys(tag))).data(), - m_stringtable->s(static_cast(pbf_node.vals(tag))).data()); + tl_builder.add_tag(m_stringtable->s(static_cast(pbf_node.keys(tag))), + m_stringtable->s(static_cast(pbf_node.vals(tag)))); } } @@ -208,8 +225,8 @@ namespace osmium { if (pbf_way.keys_size() > 0) { osmium::builder::TagListBuilder tl_builder(m_buffer, &builder); for (int tag=0; tag < pbf_way.keys_size(); ++tag) { - tl_builder.add_tag(m_stringtable->s(static_cast(pbf_way.keys(tag))).data(), - m_stringtable->s(static_cast(pbf_way.vals(tag))).data()); + tl_builder.add_tag(m_stringtable->s(static_cast(pbf_way.keys(tag))), + m_stringtable->s(static_cast(pbf_way.vals(tag)))); } } @@ -228,15 +245,15 @@ namespace osmium { int64_t ref = 0; for (int n=0; n < pbf_relation.types_size(); ++n) { ref += pbf_relation.memids(n); - rml_builder.add_member(osmpbf_membertype_to_item_type(pbf_relation.types(n)), ref, m_stringtable->s(pbf_relation.roles_sid(n)).data()); + rml_builder.add_member(osmpbf_membertype_to_item_type(pbf_relation.types(n)), ref, m_stringtable->s(pbf_relation.roles_sid(n))); } } if (pbf_relation.keys_size() > 0) { osmium::builder::TagListBuilder tl_builder(m_buffer, &builder); for (int tag=0; tag < pbf_relation.keys_size(); ++tag) { - tl_builder.add_tag(m_stringtable->s(static_cast(pbf_relation.keys(tag))).data(), - m_stringtable->s(static_cast(pbf_relation.vals(tag))).data()); + tl_builder.add_tag(m_stringtable->s(static_cast(pbf_relation.keys(tag))), + m_stringtable->s(static_cast(pbf_relation.vals(tag)))); } } @@ -262,8 +279,8 @@ namespace osmium { break; } - tl_builder.add_tag(m_stringtable->s(tag_key_pos).data(), - m_stringtable->s(dense.keys_vals(n)).data()); + tl_builder.add_tag(m_stringtable->s(tag_key_pos), + m_stringtable->s(dense.keys_vals(n))); ++n; } @@ -307,23 +324,23 @@ namespace osmium { osmium::builder::NodeBuilder builder(m_buffer); osmium::Node& node = builder.object(); - node.id(last_dense_id); + node.set_id(last_dense_id); if (dense.has_denseinfo()) { auto v = dense.denseinfo().version(i); assert(v > 0); - node.version(static_cast(v)); - node.changeset(last_dense_changeset); - node.timestamp(last_dense_timestamp * m_date_factor); - node.uid_from_signed(last_dense_uid); - node.visible(visible); - builder.add_user(m_stringtable->s(last_dense_user_sid).data()); + node.set_version(static_cast(v)); + node.set_changeset(static_cast(last_dense_changeset)); + node.set_timestamp(last_dense_timestamp * m_date_factor); + node.set_uid_from_signed(static_cast(last_dense_uid)); + node.set_visible(visible); + builder.add_user(m_stringtable->s(static_cast(last_dense_user_sid))); } else { - builder.add_user(""); + builder.add_user("", 1); } if (visible) { - builder.object().location(osmium::Location( + builder.object().set_location(osmium::Location( (last_dense_longitude * m_granularity + m_lon_offset) / (OSMPBF::lonlat_resolution / osmium::Location::coordinate_precision), (last_dense_latitude * m_granularity + m_lat_offset) / (OSMPBF::lonlat_resolution / osmium::Location::coordinate_precision))); } @@ -362,7 +379,7 @@ namespace osmium { return true; } - }; + }; // class InputQueueReader template class BlobParser { @@ -380,13 +397,10 @@ namespace osmium { m_blob_num(blob_num), m_input_queue_reader(input_queue_reader) { if (size < 0 || size > OSMPBF::max_uncompressed_blob_size) { - std::ostringstream errmsg; - errmsg << "invalid blob size: " << size; - throw std::runtime_error(errmsg.str()); + throw osmium::pbf_error(std::string("invalid blob size: " + std::to_string(size))); } - if (! input_queue_reader(m_input_buffer.get(), size)) { - // EOF - throw std::runtime_error("read error (EOF)"); + if (! input_queue_reader(m_input_buffer.get(), static_cast(size))) { + throw osmium::pbf_error("truncated data (EOF encountered)"); } } @@ -395,7 +409,7 @@ namespace osmium { void doit() { OSMPBF::Blob pbf_blob; if (!pbf_blob.ParseFromArray(m_input_buffer.get(), m_size)) { - throw std::runtime_error("failed to parse blob"); + throw osmium::pbf_error("failed to parse blob"); } if (pbf_blob.has_raw()) { @@ -410,16 +424,16 @@ namespace osmium { static_cast(this)->handle_blob(unpack_buffer); return; } else if (pbf_blob.has_lzma_data()) { - throw std::runtime_error("lzma blobs not implemented"); + throw osmium::pbf_error("lzma blobs not implemented"); } else { - throw std::runtime_error("Blob contains no data"); + throw osmium::pbf_error("blob contains no data"); } } osmium::memory::Buffer operator()() { OSMPBF::Blob pbf_blob; if (!pbf_blob.ParseFromArray(m_input_buffer.get(), m_size)) { - throw std::runtime_error("failed to parse blob"); + throw osmium::pbf_error("failed to parse blob"); } if (pbf_blob.has_raw()) { @@ -432,9 +446,9 @@ namespace osmium { std::string unpack_buffer { osmium::io::detail::zlib_uncompress(pbf_blob.zlib_data(), static_cast(raw_size)) }; return static_cast(this)->handle_blob(unpack_buffer); } else if (pbf_blob.has_lzma_data()) { - throw std::runtime_error("lzma blobs not implemented"); + throw osmium::pbf_error("lzma blobs not implemented"); } else { - throw std::runtime_error("Blob contains no data"); + throw osmium::pbf_error("blob contains no data"); } } @@ -446,8 +460,8 @@ namespace osmium { void handle_blob(const std::string& data) { OSMPBF::HeaderBlock pbf_header_block; - if (!pbf_header_block.ParseFromArray(data.data(), data.size())) { - throw std::runtime_error("Failed to parse HeaderBlock."); + if (!pbf_header_block.ParseFromArray(data.data(), static_cast_with_assert(data.size()))) { + throw osmium::pbf_error("failed to parse HeaderBlock"); } for (int i=0; i < pbf_header_block.required_features_size(); ++i) { @@ -459,13 +473,16 @@ namespace osmium { continue; } if (feature == "HistoricalInformation") { - m_header.has_multiple_object_versions(true); + m_header.set_has_multiple_object_versions(true); continue; } - std::ostringstream errmsg; - errmsg << "Required feature not supported: " << feature; - throw std::runtime_error(errmsg.str()); + throw osmium::pbf_error(std::string("required feature not supported: ") + feature); + } + + for (int i=0; i < pbf_header_block.optional_features_size(); ++i) { + const std::string& feature = pbf_header_block.optional_features(i); + m_header.set("pbf_optional_feature_" + std::to_string(i), feature); } if (pbf_header_block.has_writingprogram()) { @@ -510,7 +527,7 @@ namespace osmium { osmium::osm_entity_bits::type m_read_types; osmium::memory::Buffer handle_blob(const std::string& data) { - PBFPrimitiveBlockParser parser(data.data(), data.size(), m_read_types); + PBFPrimitiveBlockParser parser(data.data(), static_cast_with_assert(data.size()), m_read_types); return std::move(parser()); } @@ -545,9 +562,9 @@ namespace osmium { * the expected type) and a size field. * * @param expected_type Expected type of data ("OSMHeader" or "OSMData"). - * @return Size of the data read from BlobHeader (0 on EOF). + * @returns Size of the data read from BlobHeader (0 on EOF). */ - size_t read_blob_header(const char* expected_type) { + int read_blob_header(const char* expected_type) { uint32_t size_in_network_byte_order; if (! m_input_queue_reader(reinterpret_cast(&size_in_network_byte_order), sizeof(size_in_network_byte_order))) { @@ -556,29 +573,29 @@ namespace osmium { uint32_t size = ntohl(size_in_network_byte_order); if (size > static_cast(OSMPBF::max_blob_header_size)) { - throw std::runtime_error("Invalid BlobHeader size"); + throw osmium::pbf_error("invalid BlobHeader size (> max_blob_header_size)"); } unsigned char blob_header_buffer[OSMPBF::max_blob_header_size]; if (! m_input_queue_reader(blob_header_buffer, size)) { - throw std::runtime_error("Read error."); + throw osmium::pbf_error("read error"); } if (!m_blob_header.ParseFromArray(blob_header_buffer, static_cast(size))) { - throw std::runtime_error("Failed to parse BlobHeader."); + throw osmium::pbf_error("failed to parse BlobHeader"); } if (std::strcmp(m_blob_header.type().c_str(), expected_type)) { - throw std::runtime_error("Blob does not have expected type (OSMHeader in first Blob, OSMData in following Blobs)."); + throw osmium::pbf_error("blob does not have expected type (OSMHeader in first blob, OSMData in following blobs)"); } - return static_cast(m_blob_header.datasize()); + return m_blob_header.datasize(); } void parse_osm_data(osmium::osm_entity_bits::type read_types) { osmium::thread::set_thread_name("_osmium_pbf_in"); int n=0; - while (size_t size = read_blob_header("OSMData")) { + while (int size = read_blob_header("OSMData")) { DataBlobParser data_blob_parser(size, n, m_input_queue_reader, read_types); if (m_use_thread_pool) { @@ -627,7 +644,7 @@ namespace osmium { GOOGLE_PROTOBUF_VERIFY_VERSION; // handle OSMHeader - size_t size = read_blob_header("OSMHeader"); + int size = read_blob_header("OSMHeader"); { HeaderBlobParser header_blob_parser(size, m_input_queue_reader, m_header); diff --git a/ThirdParty/osmium/io/detail/pbf_output_format.hpp b/ThirdParty/osmium/io/detail/pbf_output_format.hpp index d24062c20..5ddff98ea 100644 --- a/ThirdParty/osmium/io/detail/pbf_output_format.hpp +++ b/ThirdParty/osmium/io/detail/pbf_output_format.hpp @@ -128,6 +128,7 @@ More complete outlines of real .osm.pbf files can be created using the osmpbf-ou #include #include #include +#include #include namespace osmium { @@ -153,7 +154,7 @@ namespace osmium { std::string content; msg.SerializeToString(&content); - pbf_blob.set_raw_size(content.size()); + pbf_blob.set_raw_size(static_cast_with_assert<::google::protobuf::int32>(content.size())); if (use_compression) { pbf_blob.set_zlib_data(osmium::io::detail::zlib_compress(content)); @@ -167,12 +168,12 @@ namespace osmium { OSMPBF::BlobHeader pbf_blob_header; pbf_blob_header.set_type(type); - pbf_blob_header.set_datasize(blob_data.size()); + pbf_blob_header.set_datasize(static_cast_with_assert<::google::protobuf::int32>(blob_data.size())); std::string blob_header_data; pbf_blob_header.SerializeToString(&blob_header_data); - uint32_t sz = htonl(blob_header_data.size()); + uint32_t sz = htonl(static_cast_with_assert(blob_header_data.size())); // write to output: the 4-byte BlobHeader-Size followed by the BlobHeader followed by the Blob std::string output; @@ -236,7 +237,7 @@ namespace osmium { * enough space for the string table (which typically * needs about 0.1 to 0.3% of the block size). */ - static constexpr int buffer_fill_percent = 95; + static constexpr int64_t buffer_fill_percent = 95; /** * protobuf-struct of a HeaderBlock @@ -313,7 +314,7 @@ namespace osmium { * called once for each object. */ uint16_t primitive_block_contents; - uint32_t primitive_block_size; + int primitive_block_size; // StringTable management StringTable string_table; @@ -329,7 +330,7 @@ namespace osmium { Delta m_delta_timestamp; Delta m_delta_changeset; Delta m_delta_uid; - Delta m_delta_user_sid; + Delta<::google::protobuf::int32> m_delta_user_sid; bool debug; @@ -365,10 +366,8 @@ namespace osmium { for (int i=0, l=dense->keys_vals_size(); i 0 to real string ids auto sid = dense->keys_vals(i); - assert(sid >= 0); - assert(sid < std::numeric_limits::max()); if (sid > 0) { - dense->set_keys_vals(i, string_table.map_string_id(static_cast(sid))); + dense->set_keys_vals(i, string_table.map_string_id(sid)); } } @@ -380,9 +379,7 @@ namespace osmium { // iterate over all username string-ids for (int i=0, l=denseinfo->user_sid_size(); i 0 to real string ids - auto usid = denseinfo->user_sid(i); - assert(usid < std::numeric_limits::max()); - auto user_sid = string_table.map_string_id(static_cast(usid)); + auto user_sid = string_table.map_string_id(denseinfo->user_sid(i)); // delta encode the string-id denseinfo->set_user_sid(i, m_delta_user_sid.update(user_sid)); @@ -411,7 +408,7 @@ namespace osmium { // iterate over all relation members, mapping the interim string-ids // of the role to real string ids - for (int mi=0, ml=relation->roles_sid_size(); miroles_sid_size(); ++mi) { relation->set_roles_sid(mi, string_table.map_string_id(relation->roles_sid(mi))); } } @@ -447,14 +444,14 @@ namespace osmium { * convert a double lat or lon value to an int, respecting the current blocks granularity */ int64_t lonlat2int(double lonlat) { - return round(lonlat * OSMPBF::lonlat_resolution / location_granularity()); + return static_cast(std::round(lonlat * OSMPBF::lonlat_resolution / location_granularity())); } /** * convert a timestamp to an int, respecting the current blocks granularity */ int64_t timestamp2int(time_t timestamp) { - return round(timestamp * (static_cast(1000) / date_granularity())); + return static_cast(std::round(timestamp * (1000.0 / date_granularity()))); } /** @@ -570,7 +567,7 @@ namespace osmium { void check_block_contents_counter() { if (primitive_block_contents >= max_block_contents) { store_primitive_block(); - } else if (primitive_block_size > (static_cast(OSMPBF::max_uncompressed_blob_size) * buffer_fill_percent / 100)) { + } else if (primitive_block_size > OSMPBF::max_uncompressed_blob_size * buffer_fill_percent / 100) { if (debug && has_debug_level(1)) { std::cerr << "storing primitive_block with only " << primitive_block_contents << " items, because its ByteSize (" << primitive_block_size << ") reached " << (static_cast(primitive_block_size) / static_cast(OSMPBF::max_uncompressed_blob_size) * 100.0) << "% of the maximum blob-size" << std::endl; @@ -650,7 +647,7 @@ namespace osmium { denseinfo->add_changeset(m_delta_changeset.update(node.changeset())); // copy the user id, delta encoded - denseinfo->add_uid(m_delta_uid.update(node.uid())); + denseinfo->add_uid(static_cast<::google::protobuf::int32>(m_delta_uid.update(node.uid()))); // record the user-name to the interim stringtable and copy the // interim string-id to the pbf-object @@ -808,7 +805,7 @@ namespace osmium { // when the resulting file will carry history information, add // HistoricalInformation as required feature - if (this->m_file.has_multiple_object_versions()) { + if (m_file.has_multiple_object_versions()) { pbf_header_block.add_required_features("HistoricalInformation"); } diff --git a/ThirdParty/osmium/io/detail/pbf_stringtable.hpp b/ThirdParty/osmium/io/detail/pbf_stringtable.hpp index b1bd5cdc1..6f6c54c89 100644 --- a/ThirdParty/osmium/io/detail/pbf_stringtable.hpp +++ b/ThirdParty/osmium/io/detail/pbf_stringtable.hpp @@ -34,15 +34,17 @@ DEALINGS IN THE SOFTWARE. */ #include +#include #include #include -#include #include #include #include #include +#include + namespace osmium { namespace io { @@ -83,12 +85,14 @@ namespace osmium { * IDs means less used space in the resulting file. */ struct string_info { + /// number of occurrences of this string uint16_t count; /// an intermediate-id string_id_type interim_id; - }; + + }; // struct string_info /** * Interim StringTable, storing all strings that should be written to @@ -123,8 +127,7 @@ namespace osmium { string_info& info = m_strings[string]; if (info.interim_id == 0) { ++m_size; - assert(m_size < std::numeric_limits::max()); - info.interim_id = static_cast(m_size); + info.interim_id = static_cast_with_assert(m_size); } else { info.count++; } @@ -176,6 +179,11 @@ namespace osmium { return m_id2id_map[interim_id]; } + template + string_id_type map_string_id(const T interim_id) const { + return map_string_id(static_cast_with_assert(interim_id)); + } + /** * Clear the stringtable, preparing for the next block. */ diff --git a/ThirdParty/osmium/io/detail/read_thread.hpp b/ThirdParty/osmium/io/detail/read_thread.hpp index eb8461261..0a5254686 100644 --- a/ThirdParty/osmium/io/detail/read_thread.hpp +++ b/ThirdParty/osmium/io/detail/read_thread.hpp @@ -74,10 +74,11 @@ namespace osmium { while (!m_done) { std::string data {m_decompressor->read()}; if (data.empty()) { - m_done = true; + m_queue.push(std::move(data)); + break; } m_queue.push(std::move(data)); - while (m_queue.size() > 10) { + while (m_queue.size() > 10 && !m_done) { std::this_thread::sleep_for(std::chrono::milliseconds(10)); } } diff --git a/ThirdParty/osmium/io/detail/read_write.hpp b/ThirdParty/osmium/io/detail/read_write.hpp index 305e63b11..a949296f2 100644 --- a/ThirdParty/osmium/io/detail/read_write.hpp +++ b/ThirdParty/osmium/io/detail/read_write.hpp @@ -37,13 +37,12 @@ DEALINGS IN THE SOFTWARE. #include #include #include -//#include -//#include #include + #ifndef _MSC_VER -#include +# include #else -#include +# include typedef int ssize_t; #endif @@ -61,11 +60,11 @@ namespace osmium { /** * 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 open and the stdout file descriptor (1) is returned. + * 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? - * @return File descriptor of open file. + * @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) { @@ -78,7 +77,7 @@ namespace osmium { } else { flags |= O_EXCL; } -#ifdef WIN32 +#ifdef _WIN32 flags |= O_BINARY; #endif int fd = ::open(filename.c_str(), flags, 0666); @@ -91,9 +90,10 @@ namespace osmium { /** * Open file for reading. If the file name is empty or "-", no file - * is open and the stdin file descriptor (0) is returned. + * is opened and the stdin file descriptor (0) is returned. * - * @return File descriptor of open file. + * @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) { @@ -101,7 +101,7 @@ namespace osmium { return 0; // stdin } else { int flags = O_RDONLY; -#ifdef WIN32 +#ifdef _WIN32 flags |= O_BINARY; #endif int fd = ::open(filename.c_str(), flags); @@ -112,39 +112,15 @@ namespace osmium { } } - /** - * Reads the given number of bytes into the input buffer. - * This is basically just a wrapper around read(2). - * - * @param fd File descriptor. - * @param input_buffer Buffer with data of at least size. - * @param size Number of bytes to be read. - * @return True when read was successful, false on EOF. - * @exception std::system_error On error. - */ - inline bool reliable_read(const int fd, unsigned char* input_buffer, const size_t size) { - size_t offset = 0; - while (offset < size) { - ssize_t length = ::read(fd, input_buffer + offset, size - offset); - if (length < 0) { - throw std::system_error(errno, std::system_category(), "Read failed"); - } - if (length == 0) { - return false; - } - offset += static_cast(length); - } - return true; - } - /** * Writes the given number of bytes from the output_buffer to the file descriptor. - * This is just a wrapper around write(2). + * 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 where data is written. Must be at least size bytes long. - * @param size Number of bytes to be read. - * @exception std::system_error On error. + * @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) { size_t offset = 0; @@ -157,6 +133,16 @@ namespace osmium { } 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(output_buffer), size); } diff --git a/ThirdParty/osmium/io/detail/xml_input_format.hpp b/ThirdParty/osmium/io/detail/xml_input_format.hpp index 461a947cd..1daf5d0f1 100644 --- a/ThirdParty/osmium/io/detail/xml_input_format.hpp +++ b/ThirdParty/osmium/io/detail/xml_input_format.hpp @@ -69,9 +69,15 @@ DEALINGS IN THE SOFTWARE. #include #include #include +#include namespace osmium { + /** + * Exception thrown when the XML parser failed. The exception contains + * information about the place where the error happened and the type of + * error. + */ struct xml_error : public io_error { unsigned long line; @@ -120,6 +126,8 @@ namespace osmium { * Once the header is fully parsed this exception will be thrown if * the caller is not interested in anything else except the header. * It will break off the parsing at this point. + * + * This exception is never seen by user code, it is caught internally. */ class ParserIsDone : std::exception { }; @@ -140,7 +148,7 @@ namespace osmium { ignored_relation, ignored_changeset, in_object - }; + }; // enum class context context m_context; context m_last_context; @@ -168,14 +176,81 @@ namespace osmium { osmium::thread::Queue& m_queue; std::promise& m_header_promise; - bool m_promise_fulfilled; - osmium::osm_entity_bits::type m_read_types; size_t m_max_queue_size; std::atomic& m_done; + /** + * A C++ wrapper for the Expat parser that makes sure no memory is leaked. + */ + template + class ExpatXMLParser { + + XML_Parser m_parser; + + static void XMLCALL start_element_wrapper(void* data, const XML_Char* element, const XML_Char** attrs) { + static_cast(data)->start_element(element, attrs); + } + + static void XMLCALL end_element_wrapper(void* data, const XML_Char* element) { + static_cast(data)->end_element(element); + } + + public: + + 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); + } + + ExpatXMLParser(const ExpatXMLParser&) = delete; + ExpatXMLParser(ExpatXMLParser&&) = delete; + + ExpatXMLParser& operator=(const ExpatXMLParser&) = delete; + ExpatXMLParser& operator=(ExpatXMLParser&&) = delete; + + ~ExpatXMLParser() { + XML_ParserFree(m_parser); + } + + void operator()(const std::string& data, bool last) { + if (XML_Parse(m_parser, data.data(), static_cast_with_assert(data.size()), last) == XML_STATUS_ERROR) { + throw osmium::xml_error(m_parser); + } + } + + }; // class ExpatXMLParser + + /** + * A helper class that makes sure a promise is kept. It stores + * a reference to some piece of data and to a promise and, on + * destruction, sets the value of the promise from the data. + */ + template + class PromiseKeeper { + + T& m_data; + std::promise& m_promise; + + public: + + PromiseKeeper(T& data, std::promise& promise) : + m_data(data), + m_promise(promise) { + } + + ~PromiseKeeper() { + m_promise.set_value(m_data); + } + + }; // class PromiseKeeper + public: explicit XMLParser(osmium::thread::Queue& input_queue, osmium::thread::Queue& queue, std::promise& header_promise, osmium::osm_entity_bits::type read_types, std::atomic& done) : @@ -194,7 +269,6 @@ namespace osmium { m_input_queue(input_queue), m_queue(queue), m_header_promise(header_promise), - m_promise_fulfilled(false), m_read_types(read_types), m_max_queue_size(100), m_done(done) { @@ -222,7 +296,6 @@ namespace osmium { m_input_queue(other.m_input_queue), m_queue(other.m_queue), m_header_promise(other.m_header_promise), - m_promise_fulfilled(false), m_read_types(other.m_read_types), m_max_queue_size(100), m_done(other.m_done) { @@ -237,70 +310,45 @@ namespace osmium { ~XMLParser() = default; bool operator()() { - XML_Parser parser = XML_ParserCreate(nullptr); - if (!parser) { - throw osmium::io_error("Internal error: Can not create parser"); - } - - XML_SetUserData(parser, this); - - XML_SetElementHandler(parser, start_element_wrapper, end_element_wrapper); - - try { - int done; - do { - std::string data; - m_input_queue.wait_and_pop(data); - done = data.empty(); - try { - if (XML_Parse(parser, data.data(), data.size(), done) == XML_STATUS_ERROR) { - throw osmium::xml_error(parser); - } - } catch (ParserIsDone&) { - throw; - } catch (...) { - m_queue.push(osmium::memory::Buffer()); // empty buffer to signify eof - if (!m_promise_fulfilled) { - m_promise_fulfilled = true; - m_header_promise.set_value(m_header); - } - throw; - } - } while (!done && !m_done); - header_is_done(); // make sure we'll always fulfill the promise - if (m_buffer.committed() > 0) { - m_queue.push(std::move(m_buffer)); + ExpatXMLParser parser(this); + PromiseKeeper promise_keeper(m_header, m_header_promise); + bool last; + do { + std::string data; + m_input_queue.wait_and_pop(data); + last = data.empty(); + try { + parser(data, last); + } catch (ParserIsDone&) { + return true; + } catch (...) { + m_queue.push(osmium::memory::Buffer()); // empty buffer to signify eof + throw; } - m_queue.push(osmium::memory::Buffer()); // empty buffer to signify eof - } catch (ParserIsDone&) { - // intentionally left blank + } while (!last && !m_done); + if (m_buffer.committed() > 0) { + m_queue.push(std::move(m_buffer)); } - XML_ParserFree(parser); + m_queue.push(osmium::memory::Buffer()); // empty buffer to signify eof return true; } private: - static void XMLCALL start_element_wrapper(void* data, const XML_Char* element, const XML_Char** attrs) { - static_cast(data)->start_element(element, attrs); - } - - static void XMLCALL end_element_wrapper(void* data, const XML_Char* element) { - static_cast(data)->end_element(element); - } - const char* init_object(osmium::OSMObject& object, const XML_Char** attrs) { static const char* empty = ""; const char* user = empty; if (m_in_delete_section) { - object.visible(false); + object.set_visible(false); } + + osmium::Location location; for (int count = 0; attrs[count]; count += 2) { if (!strcmp(attrs[count], "lon")) { - static_cast(object).location().lon(std::atof(attrs[count+1])); // XXX doesn't detect garbage after the number + location.set_lon(std::atof(attrs[count+1])); // XXX doesn't detect garbage after the number } else if (!strcmp(attrs[count], "lat")) { - static_cast(object).location().lat(std::atof(attrs[count+1])); // XXX doesn't detect garbage after the number + location.set_lat(std::atof(attrs[count+1])); // XXX doesn't detect garbage after the number } else if (!strcmp(attrs[count], "user")) { user = attrs[count+1]; } else { @@ -308,6 +356,10 @@ namespace osmium { } } + if (location && object.type() == osmium::item_type::node) { + static_cast(object).set_location(location); + } + return user; } @@ -320,13 +372,13 @@ namespace osmium { osmium::Location max; for (int count = 0; attrs[count]; count += 2) { if (!strcmp(attrs[count], "min_lon")) { - min.lon(atof(attrs[count+1])); + min.set_lon(atof(attrs[count+1])); } else if (!strcmp(attrs[count], "min_lat")) { - min.lat(atof(attrs[count+1])); + min.set_lat(atof(attrs[count+1])); } else if (!strcmp(attrs[count], "max_lon")) { - max.lon(atof(attrs[count+1])); + max.set_lon(atof(attrs[count+1])); } else if (!strcmp(attrs[count], "max_lat")) { - max.lat(atof(attrs[count+1])); + max.set_lat(atof(attrs[count+1])); } else if (!strcmp(attrs[count], "user")) { user = attrs[count+1]; } else { @@ -350,8 +402,7 @@ namespace osmium { for (int count = 0; attrs[count]; count += 2) { if (attrs[count][0] == 'k' && attrs[count][1] == 0) { key = attrs[count+1]; - } - if (attrs[count][0] == 'v' && attrs[count][1] == 0) { + } else if (attrs[count][0] == 'v' && attrs[count][1] == 0) { value = attrs[count+1]; } } @@ -363,12 +414,8 @@ namespace osmium { } void header_is_done() { - if (!m_promise_fulfilled) { - m_header_promise.set_value(m_header); - m_promise_fulfilled = true; - if (m_read_types == osmium::osm_entity_bits::nothing) { - throw ParserIsDone(); - } + if (m_read_types == osmium::osm_entity_bits::nothing) { + throw ParserIsDone(); } } @@ -377,7 +424,7 @@ namespace osmium { case context::root: if (!strcmp(element, "osm") || !strcmp(element, "osmChange")) { if (!strcmp(element, "osmChange")) { - m_header.has_multiple_object_versions(true); + m_header.set_has_multiple_object_versions(true); } for (int count = 0; attrs[count]; count += 2) { if (!strcmp(attrs[count], "version")) { @@ -438,13 +485,13 @@ namespace osmium { osmium::Location max; for (int count = 0; attrs[count]; count += 2) { if (!strcmp(attrs[count], "minlon")) { - min.lon(atof(attrs[count+1])); + min.set_lon(atof(attrs[count+1])); } else if (!strcmp(attrs[count], "minlat")) { - min.lat(atof(attrs[count+1])); + min.set_lat(atof(attrs[count+1])); } else if (!strcmp(attrs[count], "maxlon")) { - max.lon(atof(attrs[count+1])); + max.set_lon(atof(attrs[count+1])); } else if (!strcmp(attrs[count], "maxlat")) { - max.lat(atof(attrs[count+1])); + max.set_lat(atof(attrs[count+1])); } } osmium::Box box; @@ -610,7 +657,7 @@ namespace osmium { } } - }; // XMLParser + }; // class XMLParser class XMLInputFormat : public osmium::io::detail::InputFormat { @@ -639,7 +686,11 @@ namespace osmium { } ~XMLInputFormat() { - m_done = true; + try { + close(); + } catch (...) { + // ignore any exceptions at this point because destructor should not throw + } } virtual osmium::io::Header header() override final { @@ -657,6 +708,11 @@ namespace osmium { return buffer; } + void close() { + m_done = true; + m_parser_task.close(); + } + }; // class XMLInputFormat namespace { diff --git a/ThirdParty/osmium/io/detail/xml_output_format.hpp b/ThirdParty/osmium/io/detail/xml_output_format.hpp index fc9e1e630..3e451bd1c 100644 --- a/ThirdParty/osmium/io/detail/xml_output_format.hpp +++ b/ThirdParty/osmium/io/detail/xml_output_format.hpp @@ -96,10 +96,13 @@ namespace osmium { void oprintf(std::string& out, const char* format, T value) { char buffer[tmp_buffer_size+1]; size_t max_size = sizeof(buffer)/sizeof(char); +#ifndef NDEBUG + int len = +#endif #ifndef _MSC_VER - int len = snprintf(buffer, max_size, format, value); + snprintf(buffer, max_size, format, value); #else - int len = _snprintf(buffer, max_size, format, value); + _snprintf(buffer, max_size, format, value); #endif assert(len > 0 && static_cast(len) < max_size); out += buffer; @@ -115,7 +118,7 @@ namespace osmium { op_create = 1, op_modify = 2, op_delete = 3 - }; + }; // enum class operation osmium::memory::Buffer m_input_buffer; @@ -257,9 +260,9 @@ namespace osmium { if (node.location()) { m_out += " lat=\""; - osmium::Location::coordinate2string(std::back_inserter(m_out), node.location().lat_without_check()); + osmium::util::double2string(std::back_inserter(m_out), node.location().lat_without_check(), 7); m_out += "\" lon=\""; - osmium::Location::coordinate2string(std::back_inserter(m_out), node.location().lon_without_check()); + osmium::util::double2string(std::back_inserter(m_out), node.location().lon_without_check(), 7); m_out += "\""; } @@ -402,7 +405,7 @@ namespace osmium { } void write_buffer(osmium::memory::Buffer&& buffer) override final { - XMLOutputBlock output_block(std::move(buffer), m_write_visible_flag, m_file.is_true("xml_change_format")); + osmium::thread::SharedPtrWrapper output_block(std::move(buffer), m_write_visible_flag, m_file.is_true("xml_change_format")); m_output_queue.push(osmium::thread::Pool::instance().submit(std::move(output_block))); while (m_output_queue.size() > 10) { std::this_thread::sleep_for(std::chrono::milliseconds(100)); // XXX diff --git a/ThirdParty/osmium/io/detail/zlib.hpp b/ThirdParty/osmium/io/detail/zlib.hpp index 932c04835..7e1deca80 100644 --- a/ThirdParty/osmium/io/detail/zlib.hpp +++ b/ThirdParty/osmium/io/detail/zlib.hpp @@ -50,7 +50,7 @@ namespace osmium { * Compress data using zlib. * * @param input Data to compress. - * @return Compressed data. + * @returns Compressed data. */ inline std::string zlib_compress(const std::string& input) { unsigned long output_size = ::compressBound(input.size()); @@ -74,7 +74,7 @@ namespace osmium { * * @param input Compressed input data. * @param raw_size Size of uncompressed data. - * @return Uncompressed data. + * @returns Uncompressed data. */ inline std::string zlib_uncompress(const std::string& input, unsigned long raw_size) { std::string output(raw_size, '\0'); diff --git a/ThirdParty/osmium/io/file.hpp b/ThirdParty/osmium/io/file.hpp index 3aa76f77a..908ada70a 100644 --- a/ThirdParty/osmium/io/file.hpp +++ b/ThirdParty/osmium/io/file.hpp @@ -1,319 +1,358 @@ -#ifndef OSMIUM_IO_FILE_HPP -#define OSMIUM_IO_FILE_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 -#include -#include -#include -#include - -#include -#include -#include - -namespace osmium { - - struct io_error : public std::runtime_error { - - io_error(const std::string& what) : - std::runtime_error(what) { - } - - io_error(const char* what) : - std::runtime_error(what) { - } - - }; // struct io_error - - /** - * @brief Everything related to input and output of OSM data. - */ - namespace io { - - namespace detail { - - inline std::vector split(const std::string& in, const char delim) { - std::vector 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; - - 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. - */ - explicit File(const std::string& filename = "", const std::string& format = "") : - Options(), - m_filename(filename), - m_format_string(format) { - - // stdin/stdout - if (filename == "" || filename == "-") { - m_filename = ""; - default_settings_for_stdinout(); - } - - // filename is actually a URL - std::string protocol = m_filename.substr(0, m_filename.find_first_of(':')); - if (protocol == "http" || protocol == "https") { - default_settings_for_url(); - } - - detect_format_from_suffix(m_filename); - - if (format != "") { - parse_format(format); - } - } - - File(const File& other) = default; - File& operator=(const File& other) = default; - - File(File&& other) = default; - File& operator=(File&& other) = default; - - ~File() = default; - - void parse_format(const std::string& format) { - std::vector 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 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(); - } - - 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 std::runtime_error - */ - void 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 std::runtime_error(msg); - } - } - - /** - * Set default settings for type and encoding when the filename is - * empty or "-". If you want to have a different default setting - * override this in a subclass. - */ - void default_settings_for_stdinout() { - m_file_format = file_format::unknown; - m_file_compression = file_compression::none; - } - - /** - * Set default settings for type and encoding when the filename is - * a normal file. If you want to have a different default setting - * override this in a subclass. - */ - void default_settings_for_file() { - m_file_format = file_format::unknown; - m_file_compression = file_compression::none; - } - - /** - * Set default settings for type and encoding when the filename is a URL. - * If you want to have a different default setting override this in a - * subclass. - */ - void default_settings_for_url() { - m_file_format = file_format::xml; - m_file_compression = file_compression::none; - } - - file_format format() const { - return m_file_format; - } - - File& format(file_format format) { - m_file_format = format; - return *this; - } - - file_compression compression() const { - return m_file_compression; - } - - File& compression(file_compression compression) { - m_file_compression = compression; - return *this; - } - - bool has_multiple_object_versions() const { - return m_has_multiple_object_versions; - } - - File& has_multiple_object_versions(bool value) { - 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 { - return m_filename; - } - - }; // class File - - } // namespace io - -} // namespace osmium - -#endif // OSMIUM_IO_FILE_HPP +#ifndef OSMIUM_IO_FILE_HPP +#define OSMIUM_IO_FILE_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include +#include + +#include +#include +#include + +namespace osmium { + + /** + * Exception thrown when some kind of input/output operation failed. + */ + struct io_error : public std::runtime_error { + + io_error(const std::string& what) : + std::runtime_error(what) { + } + + io_error(const char* what) : + std::runtime_error(what) { + } + + }; // struct io_error + + /** + * @brief Everything related to input and output of OSM data. + */ + namespace io { + + namespace detail { + + inline std::vector split(const std::string& in, const char delim) { + std::vector 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. + */ + 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 (filename == "" || filename == "-") { + m_filename = ""; + default_settings_for_stdinout(); + } + + // filename is actually a URL + std::string protocol = m_filename.substr(0, m_filename.find_first_of(':')); + if (protocol == "http" || protocol == "https") { + default_settings_for_url(); + } + + detect_format_from_suffix(m_filename); + + if (format != "") { + 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) { + + default_settings_for_stdinout(); + + if (format != "") { + parse_format(format); + } + } + + File(const File& other) = default; + File& operator=(const File& other) = default; + + File(File&& other) = default; + File& operator=(File&& other) = 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 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 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(); + } + + 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 std::runtime_error + */ + void 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 std::runtime_error(msg); + } + } + + /** + * Set default settings for type and encoding when the filename is + * empty or "-". If you want to have a different default setting + * override this in a subclass. + */ + void default_settings_for_stdinout() { + m_file_format = file_format::unknown; + m_file_compression = file_compression::none; + } + + /** + * Set default settings for type and encoding when the filename is + * a normal file. If you want to have a different default setting + * override this in a subclass. + */ + void default_settings_for_file() { + m_file_format = file_format::unknown; + m_file_compression = file_compression::none; + } + + /** + * Set default settings for type and encoding when the filename is a URL. + * If you want to have a different default setting override this in a + * subclass. + */ + void default_settings_for_url() { + m_file_format = file_format::xml; + m_file_compression = file_compression::none; + } + + 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 diff --git a/ThirdParty/osmium/io/file_compression.hpp b/ThirdParty/osmium/io/file_compression.hpp index 8de416d38..c71871553 100644 --- a/ThirdParty/osmium/io/file_compression.hpp +++ b/ThirdParty/osmium/io/file_compression.hpp @@ -45,6 +45,9 @@ namespace osmium { 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: @@ -55,6 +58,7 @@ namespace osmium { return "bzip2"; } } +#pragma GCC diagnostic pop template inline std::basic_ostream& operator<<(std::basic_ostream& out, const file_compression compression) { diff --git a/ThirdParty/osmium/io/file_format.hpp b/ThirdParty/osmium/io/file_format.hpp index 649e965bf..5a4aa5c01 100644 --- a/ThirdParty/osmium/io/file_format.hpp +++ b/ThirdParty/osmium/io/file_format.hpp @@ -47,6 +47,9 @@ namespace osmium { json = 4 }; +// 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: @@ -61,6 +64,7 @@ namespace osmium { return "JSON"; } } +#pragma GCC diagnostic pop template inline std::basic_ostream& operator<<(std::basic_ostream& out, const file_format format) { diff --git a/ThirdParty/osmium/io/gzip_compression.hpp b/ThirdParty/osmium/io/gzip_compression.hpp index f9afed06c..db99acb9a 100644 --- a/ThirdParty/osmium/io/gzip_compression.hpp +++ b/ThirdParty/osmium/io/gzip_compression.hpp @@ -38,15 +38,52 @@ DEALINGS IN THE SOFTWARE. #include #include +#include #include #include #include +#include +#include namespace osmium { + /** + * Exception thrown when there are problems compressing or + * decompressing gzip files. + */ + struct gzip_error : public std::runtime_error { + + int gzip_error_code; + int system_errno; + + gzip_error(const std::string& what, int error_code) : + std::runtime_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 { gzFile m_gzfile; @@ -57,22 +94,30 @@ namespace osmium { Compressor(), m_gzfile(::gzdopen(fd, "w")) { if (!m_gzfile) { - throw std::runtime_error("initialization of gzip compression failed"); + detail::throw_gzip_error(m_gzfile, "write initialization failed"); } } ~GzipCompressor() override final { - this->close(); + close(); } void write(const std::string& data) override final { - ::gzwrite(m_gzfile, data.data(), data.size()); + if (!data.empty()) { + int nwrite = ::gzwrite(m_gzfile, data.data(), static_cast_with_assert(data.size())); + if (nwrite == 0) { + detail::throw_gzip_error(m_gzfile, "write failed"); + } + } } void close() override final { if (m_gzfile) { - ::gzclose(m_gzfile); + int result = ::gzclose(m_gzfile); m_gzfile = nullptr; + if (result != Z_OK) { + detail::throw_gzip_error(m_gzfile, "write close failed", result); + } } } @@ -88,20 +133,19 @@ namespace osmium { Decompressor(), m_gzfile(::gzdopen(fd, "r")) { if (!m_gzfile) { - throw std::runtime_error("initialization of gzip compression failed"); + detail::throw_gzip_error(m_gzfile, "read initialization failed"); } } ~GzipDecompressor() override final { - this->close(); + close(); } std::string read() override final { std::string buffer(osmium::io::Decompressor::input_buffer_size, '\0'); - int nread = ::gzread(m_gzfile, const_cast(buffer.data()), buffer.size()); + int nread = ::gzread(m_gzfile, const_cast(buffer.data()), static_cast_with_assert(buffer.size())); if (nread < 0) { - throw std::runtime_error("gzip read failed"); // XXX better error detection and reporting -// throw std::system_error(errno, std::system_category(), "Read failed"); + detail::throw_gzip_error(m_gzfile, "read failed"); } buffer.resize(static_cast(nread)); return buffer; @@ -109,18 +153,80 @@ namespace osmium { void close() override final { if (m_gzfile) { - ::gzclose(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(const_cast(buffer)); + m_zstream.avail_in = static_cast_with_assert(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() override final { + inflateEnd(&m_zstream); + } + + std::string read() override final { + if (!m_buffer) { + return std::string(); + } + + const size_t buffer_size = 10240; + std::string output(buffer_size, '\0'); + m_zstream.next_out = reinterpret_cast(const_cast(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(m_zstream.next_out - reinterpret_cast(output.data()))); + return output; + } + + }; // class GzipBufferDecompressor + namespace { const bool registered_gzip_compression = osmium::io::CompressionFactory::instance().register_compression(osmium::io::file_compression::gzip, [](int fd) { return new osmium::io::GzipCompressor(fd); }, - [](int fd) { return new osmium::io::GzipDecompressor(fd); } + [](int fd) { return new osmium::io::GzipDecompressor(fd); }, + [](const char* buffer, size_t size) { return new osmium::io::GzipBufferDecompressor(buffer, size); } ); } // anonymous namespace diff --git a/ThirdParty/osmium/io/header.hpp b/ThirdParty/osmium/io/header.hpp index c3294756a..0fdbf77fc 100644 --- a/ThirdParty/osmium/io/header.hpp +++ b/ThirdParty/osmium/io/header.hpp @@ -73,15 +73,15 @@ namespace osmium { ~Header() = default; - std::vector& boxes() { + std::vector& boxes() noexcept { return m_boxes; } - const std::vector& boxes() const { + const std::vector& boxes() const noexcept { return m_boxes; } - Header& boxes(const std::vector& boxes) { + Header& boxes(const std::vector& boxes) noexcept { m_boxes = boxes; return *this; } @@ -104,12 +104,12 @@ namespace osmium { return *this; } - bool has_multiple_object_versions() const { + bool has_multiple_object_versions() const noexcept { return m_has_multiple_object_versions; } - Header& has_multiple_object_versions(bool h) { - m_has_multiple_object_versions = h; + Header& set_has_multiple_object_versions(bool value) noexcept { + m_has_multiple_object_versions = value; return *this; } diff --git a/ThirdParty/osmium/io/input_iterator.hpp b/ThirdParty/osmium/io/input_iterator.hpp index 06be82dc4..a2e3b83b3 100644 --- a/ThirdParty/osmium/io/input_iterator.hpp +++ b/ThirdParty/osmium/io/input_iterator.hpp @@ -89,7 +89,7 @@ namespace osmium { } // end iterator - InputIterator() : + InputIterator() noexcept : m_source(nullptr) { } @@ -110,13 +110,13 @@ namespace osmium { return tmp; } - bool operator==(const InputIterator& rhs) const { + bool operator==(const InputIterator& rhs) const noexcept { return m_source == rhs.m_source && m_buffer == rhs.m_buffer && m_iter == rhs.m_iter; } - bool operator!=(const InputIterator& rhs) const { + bool operator!=(const InputIterator& rhs) const noexcept { return !(*this == rhs); } diff --git a/ThirdParty/osmium/io/output_iterator.hpp b/ThirdParty/osmium/io/output_iterator.hpp index d83b10c54..e6a9cc096 100644 --- a/ThirdParty/osmium/io/output_iterator.hpp +++ b/ThirdParty/osmium/io/output_iterator.hpp @@ -1,114 +1,116 @@ -#ifndef OSMIUM_IO_OUTPUT_ITERATOR_HPP -#define OSMIUM_IO_OUTPUT_ITERATOR_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 -#include -#include -#include - -#include -#include - -namespace osmium { - - namespace memory { - class Item; - } // namespace memory - - namespace io { - - template - class OutputIterator : public std::iterator { - - struct buffer_wrapper { - osmium::memory::Buffer buffer; - - buffer_wrapper(size_t buffer_size) : - buffer(buffer_size, osmium::memory::Buffer::auto_grow::no) { - } - }; - - static constexpr size_t default_buffer_size = 10 * 1024 * 1024; - - TDest& m_destination; - - std::shared_ptr m_buffer_wrapper; - - public: - - explicit OutputIterator(TDest& destination, const size_t buffer_size = default_buffer_size) : - m_destination(destination), - m_buffer_wrapper(std::make_shared(buffer_size)) { - } - - void flush() { - osmium::memory::Buffer buffer(m_buffer_wrapper->buffer.capacity(), osmium::memory::Buffer::auto_grow::no); - std::swap(m_buffer_wrapper->buffer, buffer); - m_destination(std::move(buffer)); - } - - OutputIterator& operator=(const osmium::memory::Item& item) { - try { - m_buffer_wrapper->buffer.push_back(item); - } catch (osmium::memory::BufferIsFull&) { - flush(); - m_buffer_wrapper->buffer.push_back(item); - } - return *this; - } - - OutputIterator& operator=(const osmium::DiffObject& diff) { - return this->operator=(diff.curr()); - } - - OutputIterator& operator*() { - return *this; - } - - OutputIterator& operator++() { - return *this; - } - - OutputIterator& operator++(int) { - return *this; - } - - }; // class OutputIterator - - } // namespace io - -} // namespace osmium - -#endif // OSMIUM_IO_OUTPUT_ITERATOR_HPP +#ifndef OSMIUM_IO_OUTPUT_ITERATOR_HPP +#define OSMIUM_IO_OUTPUT_ITERATOR_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include + +#include +#include + +namespace osmium { + + namespace memory { + class Item; + } // namespace memory + + namespace io { + + template + class OutputIterator : public std::iterator { + + struct buffer_wrapper { + + osmium::memory::Buffer buffer; + + buffer_wrapper(size_t buffer_size) : + buffer(buffer_size, osmium::memory::Buffer::auto_grow::no) { + } + + }; // struct buffer_wrapper + + static constexpr size_t default_buffer_size = 10 * 1024 * 1024; + + TDest* m_destination; + + std::shared_ptr m_buffer_wrapper; + + public: + + explicit OutputIterator(TDest& destination, const size_t buffer_size = default_buffer_size) : + m_destination(&destination), + m_buffer_wrapper(std::make_shared(buffer_size)) { + } + + void flush() { + osmium::memory::Buffer buffer(m_buffer_wrapper->buffer.capacity(), osmium::memory::Buffer::auto_grow::no); + std::swap(m_buffer_wrapper->buffer, buffer); + (*m_destination)(std::move(buffer)); + } + + OutputIterator& operator=(const osmium::memory::Item& item) { + try { + m_buffer_wrapper->buffer.push_back(item); + } catch (osmium::buffer_is_full&) { + flush(); + m_buffer_wrapper->buffer.push_back(item); + } + return *this; + } + + OutputIterator& operator=(const osmium::DiffObject& diff) { + return this->operator=(diff.curr()); + } + + OutputIterator& operator*() { + return *this; + } + + OutputIterator& operator++() { + return *this; + } + + OutputIterator& operator++(int) { + return *this; + } + + }; // class OutputIterator + + } // namespace io + +} // namespace osmium + +#endif // OSMIUM_IO_OUTPUT_ITERATOR_HPP diff --git a/ThirdParty/osmium/io/reader.hpp b/ThirdParty/osmium/io/reader.hpp index 8acac94b5..29c2b24ae 100644 --- a/ThirdParty/osmium/io/reader.hpp +++ b/ThirdParty/osmium/io/reader.hpp @@ -41,15 +41,16 @@ DEALINGS IN THE SOFTWARE. #include #include #include -#ifndef _WIN32 -#include -#endif -#ifndef _MSC_VER -#include -#else -#endif #include +#ifndef _WIN32 +# include +#endif + +#ifndef _MSC_VER +# include +#endif + #include #include #include @@ -95,7 +96,7 @@ namespace osmium { * * @param command Command to execute in the child. * @param filename Filename to give to command as argument. - * @return File descriptor of pipe in the parent. + * @returns File descriptor of pipe in the parent. * @throws std::system_error if a system call fails. */ static int execute(const std::string& command, const std::string& filename, int* childpid) { @@ -140,7 +141,7 @@ namespace osmium { * are opened by executing the "curl" program (which must be installed) * and reading from its output. * - * @return File descriptor of open file or pipe. + * @returns File descriptor of open file or pipe. * @throws std::system_error if a system call fails. */ static int open_input_file_or_url(const std::string& filename, int* childpid) { @@ -173,7 +174,9 @@ namespace osmium { m_input_done(false), m_childpid(0), m_input_queue(), - m_decompressor(osmium::io::CompressionFactory::instance().create_decompressor(file.compression(), open_input_file_or_url(m_file.filename(), &m_childpid))), + m_decompressor(m_file.buffer() ? + osmium::io::CompressionFactory::instance().create_decompressor(file.compression(), m_file.buffer(), m_file.buffer_size()) : + osmium::io::CompressionFactory::instance().create_decompressor(file.compression(), open_input_file_or_url(m_file.filename(), &m_childpid))), m_read_task(m_input_queue, m_decompressor.get(), m_input_done), m_input(osmium::io::detail::InputFormatFactory::instance().create_input(m_file, m_read_which_entities, m_input_queue)) { } @@ -190,7 +193,11 @@ namespace osmium { Reader& operator=(const Reader&) = delete; ~Reader() { - close(); + try { + close(); + } + catch (...) { + } } /** @@ -233,7 +240,10 @@ namespace osmium { /** * Reads the next buffer from the input. An invalid buffer signals - * end-of-file. Do not call read() after the end-of-file. + * end-of-file. After end-of-file all read() calls will return an + * invalid buffer. An invalid buffer is also always returned if + * osmium::osm_entity_bits::nothing was set when the Reader was + * constructed. * * @returns Buffer. * @throws Some form of std::runtime_error if there is an error. @@ -243,12 +253,25 @@ namespace osmium { // it in this (the main) thread. m_read_task.check_for_exception(); - if (m_read_which_entities == osmium::osm_entity_bits::nothing) { + if (m_read_which_entities == osmium::osm_entity_bits::nothing || m_input_done) { // If the caller didn't want anything but the header, it will // always get an empty buffer here. return osmium::memory::Buffer(); } - return m_input->read(); + + osmium::memory::Buffer buffer = m_input->read(); + if (!buffer) { + m_input_done = true; + } + return buffer; + } + + /** + * Has the end of file been reached? This is set after the last + * data has been read. It is also set by calling close(). + */ + bool eof() { + return m_input_done; } }; // class Reader diff --git a/ThirdParty/osmium/io/writer.hpp b/ThirdParty/osmium/io/writer.hpp index c5ff05cf2..da685c9cb 100644 --- a/ThirdParty/osmium/io/writer.hpp +++ b/ThirdParty/osmium/io/writer.hpp @@ -90,6 +90,7 @@ namespace osmium { m_output(osmium::io::detail::OutputFormatFactory::instance().create_output(m_file, m_output_queue)), m_compressor(osmium::io::CompressionFactory::instance().create_compressor(file.compression(), osmium::io::detail::open_for_writing(m_file.filename(), allow_overwrite))), m_write_task(m_output_queue, m_compressor.get()) { + assert(!m_file.buffer()); m_output->write_header(header); } @@ -121,7 +122,7 @@ namespace osmium { } /** - * Flush writes to output file and close it. If you do not + * Flush writes to output file and closes it. If you do not * call this, the destructor of Writer will also do the same * thing. But because this call might thrown an exception, * it is better to call close() explicitly. diff --git a/ThirdParty/osmium/memory/buffer.hpp b/ThirdParty/osmium/memory/buffer.hpp index a8a9c7441..fe040caf1 100644 --- a/ThirdParty/osmium/memory/buffer.hpp +++ b/ThirdParty/osmium/memory/buffer.hpp @@ -49,17 +49,24 @@ DEALINGS IN THE SOFTWARE. namespace osmium { + /** + * Exception thrown by the osmium::memory::Buffer class when somebody tries + * to write data into a buffer and it doesn't fit. Buffers with internal + * memory management will not throw this exception, but increase their size. + */ + struct buffer_is_full : public std::runtime_error { + + buffer_is_full() : + std::runtime_error("Osmium buffer is full") { + } + + }; // struct buffer_is_full + /** * @brief Memory management of items in buffers and iterators over this data. */ namespace memory { - /** - * Exception thrown by the Buffer class when somebody tries to write data - * into the buffer and it doesn't fit. - */ - class BufferIsFull : public std::exception {}; - /** * A memory area for storing OSM objects and other items. Each item stored * has a type and a length. See the Item class for details. @@ -80,7 +87,7 @@ namespace osmium { * create a Buffer object and have it manage the memory internally. It will * dynamically allocate memory and free it again after use. * - * By default, if a buffer gets full it will throw a BufferIsFull exception. + * By default, if a buffer gets full it will throw a buffer_is_full exception. * You can use the set_full_callback() method to set a callback functor * which will be called instead of throwing an exception. */ @@ -91,7 +98,7 @@ namespace osmium { enum class auto_grow : bool { yes = true, no = false - }; + }; // enum class auto_grow private: @@ -112,7 +119,7 @@ namespace osmium { * buffer, ie an empty hull of a buffer that has no actual memory * associated with it. It can be used to signify end-of-input. */ - Buffer() : + Buffer() noexcept : m_memory(), m_data(nullptr), m_capacity(0), @@ -126,7 +133,7 @@ namespace osmium { * * @param data A pointer to some already initialized data. * @param size The size of the initialized data. - * @exception std::invalid_argument When the size isn't a multiple of the alignment. + * @throws std::invalid_argument When the size isn't a multiple of the alignment. */ explicit Buffer(unsigned char* data, size_t size) : m_memory(), @@ -146,7 +153,7 @@ namespace osmium { * @param data A pointer to some (possibly initialized) data. * @param capacity The size of the memory for this buffer. * @param committed The size of the initialized data. If this is 0, the buffer startes out empty. - * @exception std::invalid_argument When the capacity or committed isn't a multiple of the alignment. + * @throws std::invalid_argument When the capacity or committed isn't a multiple of the alignment. */ explicit Buffer(unsigned char* data, size_t capacity, size_t committed) : m_memory(), @@ -193,21 +200,21 @@ namespace osmium { /** * Return a pointer to data inside the buffer. */ - unsigned char* data() const { + unsigned char* data() const noexcept { return m_data; } /** * Returns the capacity of the buffer, ie how many bytes it can contain. */ - size_t capacity() const { + size_t capacity() const noexcept { return m_capacity; } /** * Returns the number of bytes already filled in this buffer. */ - size_t committed() const { + size_t committed() const noexcept { return m_committed; } @@ -215,7 +222,7 @@ namespace osmium { * Returns the number of bytes currently filled in this buffer that * are not yet committed. */ - size_t written() const { + size_t written() const noexcept { return m_written; } @@ -223,13 +230,13 @@ namespace osmium { * This tests if the current state of the buffer is aligned * properly. Can be used for asserts. */ - bool is_aligned() const { + bool is_aligned() const noexcept { return (m_written % align_bytes == 0) && (m_committed % align_bytes == 0); } /** * Set functor to be called whenever the buffer is full - * instead of throwing BufferIsFull. + * instead of throwing buffer_is_full. */ void set_full_callback(std::function full) { m_full = full; @@ -260,7 +267,7 @@ namespace osmium { /** * Mark currently written bytes in the buffer as committed. * - * @return Last number of committed bytes before this commit. + * @returns Last number of committed bytes before this commit. */ size_t commit() { assert(is_aligned()); @@ -280,7 +287,7 @@ namespace osmium { /** * Clear the buffer. * - * @return Number of bytes in the buffer before it was cleared. + * @returns Number of bytes in the buffer before it was cleared. */ size_t clear() { const size_t committed = m_committed; @@ -293,7 +300,7 @@ namespace osmium { * Get the data in the buffer at the given offset. * * @tparam T Type we want to the data to be interpreted as. - * @return Reference of given type pointing to the data in the buffer. + * @returns Reference of given type pointing to the data in the buffer. */ template T& get(const size_t offset) const { @@ -317,13 +324,13 @@ namespace osmium { * * If no callback is defined and this buffer uses internal * memory management, the buffers capacity is grown, so that * the new data will fit. - * * Else the BufferIsFull exception is thrown. + * * Else the buffer_is_full exception is thrown. * * @param size Number of bytes to reserve. - * @return Pointer to reserved space. Note that this pointer is + * @returns Pointer to reserved space. Note that this pointer is * only guaranteed to be valid until the next call to * reserve_space(). - * @throw BufferIsFull Might be thrown if the buffer is full. + * @throws osmium::buffer_is_full Might be thrown if the buffer is full. */ unsigned char* reserve_space(const size_t size) { if (m_written + size > m_capacity) { @@ -337,7 +344,7 @@ namespace osmium { } grow(new_capacity); } else { - throw BufferIsFull(); + throw osmium::buffer_is_full(); } } unsigned char* data = &m_data[m_written]; @@ -354,7 +361,7 @@ namespace osmium { * * @tparam T Class of the item to be copied. * @param item Reference to the item to be copied. - * @return Reference to newly copied data in the buffer. + * @returns Reference to newly copied data in the buffer. */ template T& add_item(const T& item) { @@ -483,6 +490,10 @@ namespace osmium { */ template void purge_removed(TCallbackClass* callback) { + if (begin() == end()) { + return; + } + iterator it_write = begin(); iterator next; @@ -490,29 +501,29 @@ namespace osmium { next = std::next(it_read); if (!it_read->removed()) { if (it_read != it_write) { - assert(it_read->data() >= data()); - assert(it_write->data() >= data()); - size_t old_offset = static_cast(it_read->data() - data()); - size_t new_offset = static_cast(it_write->data() - data()); + assert(it_read.data() >= data()); + assert(it_write.data() >= data()); + size_t old_offset = static_cast(it_read.data() - data()); + size_t new_offset = static_cast(it_write.data() - data()); callback->moving_in_buffer(old_offset, new_offset); - std::memmove(it_write->data(), it_read->data(), it_read->padded_size()); + std::memmove(it_write.data(), it_read.data(), it_read->padded_size()); } - ++it_write; + it_write.advance_once(); } } - assert(it_write->data() >= data()); - m_written = static_cast(it_write->data() - data()); + assert(it_write.data() >= data()); + m_written = static_cast(it_write.data() - data()); m_committed = m_written; } }; // class Buffer - inline bool operator==(const Buffer& lhs, const Buffer& rhs) { + inline bool operator==(const Buffer& lhs, const Buffer& rhs) noexcept { return lhs.data() == rhs.data() && lhs.capacity() == rhs.capacity() && lhs.committed() == rhs.committed(); } - inline bool operator!=(const Buffer& lhs, const Buffer& rhs) { + inline bool operator!=(const Buffer& lhs, const Buffer& rhs) noexcept { return ! (lhs == rhs); } diff --git a/ThirdParty/osmium/memory/collection.hpp b/ThirdParty/osmium/memory/collection.hpp index c6256b175..b25dd64ec 100644 --- a/ThirdParty/osmium/memory/collection.hpp +++ b/ThirdParty/osmium/memory/collection.hpp @@ -1,153 +1,153 @@ -#ifndef OSMIUM_MEMORY_COLLECTION_HPP -#define OSMIUM_MEMORY_COLLECTION_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 -#include -#include - -#include - -namespace osmium { - - namespace memory { - - template - class CollectionIterator : public std::iterator { - - // This data_type is either 'unsigned char*' or 'const unsigned char*' depending - // on whether TMember is const. This allows this class to be used as an iterator and - // as a const_iterator. - typedef typename std::conditional::value, const unsigned char*, unsigned char*>::type data_type; - - data_type m_data; - - public: - - CollectionIterator() : - m_data(nullptr) { - } - - CollectionIterator(data_type data) : - m_data(data) { - } - - CollectionIterator& operator++() { - m_data = reinterpret_cast(m_data)->next(); - return *static_cast*>(this); - } - - CollectionIterator operator++(int) { - CollectionIterator tmp(*this); - operator++(); - return tmp; - } - - bool operator==(const CollectionIterator& rhs) const { - return m_data == rhs.m_data; - } - - bool operator!=(const CollectionIterator& rhs) const { - return m_data != rhs.m_data; - } - - unsigned char* data() const { - return m_data; - } - - TMember& operator*() const { - return *reinterpret_cast(m_data); - } - - TMember* operator->() const { - return reinterpret_cast(m_data); - } - - template - friend std::basic_ostream& operator<<(std::basic_ostream& out, const CollectionIterator& iter) { - return out << static_cast(iter.m_data); - } - - }; // class CollectionIterator - - template - class Collection : public Item { - - public: - - typedef CollectionIterator iterator; - typedef CollectionIterator const_iterator; - typedef TMember value_type; - - static constexpr osmium::item_type itemtype = TCollectionItemType; - - Collection() : - Item(sizeof(Collection), TCollectionItemType) { - } - - bool empty() const { - return sizeof(Collection) == byte_size(); - } - - iterator begin() { - return iterator(data() + sizeof(Collection)); - } - - iterator end() { - return iterator(data() + byte_size()); - } - - const_iterator cbegin() const { - return const_iterator(data() + sizeof(Collection)); - } - - const_iterator cend() const { - return const_iterator(data() + byte_size()); - } - - const_iterator begin() const { - return cbegin(); - } - - const_iterator end() const { - return cend(); - } - - }; // class Collection - - } // namespace memory - -} // namespace osmium - -#endif // OSMIUM_MEMORY_COLLECTION_HPP +#ifndef OSMIUM_MEMORY_COLLECTION_HPP +#define OSMIUM_MEMORY_COLLECTION_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include + +#include + +namespace osmium { + + namespace memory { + + template + class CollectionIterator : public std::iterator { + + // This data_type is either 'unsigned char*' or 'const unsigned char*' depending + // on whether TMember is const. This allows this class to be used as an iterator and + // as a const_iterator. + typedef typename std::conditional::value, const unsigned char*, unsigned char*>::type data_type; + + data_type m_data; + + public: + + CollectionIterator() noexcept : + m_data(nullptr) { + } + + CollectionIterator(data_type data) noexcept : + m_data(data) { + } + + CollectionIterator& operator++() { + m_data = reinterpret_cast(m_data)->next(); + return *static_cast*>(this); + } + + CollectionIterator operator++(int) { + CollectionIterator tmp(*this); + operator++(); + return tmp; + } + + bool operator==(const CollectionIterator& rhs) const noexcept { + return m_data == rhs.m_data; + } + + bool operator!=(const CollectionIterator& rhs) const noexcept { + return m_data != rhs.m_data; + } + + unsigned char* data() const noexcept { + return m_data; + } + + TMember& operator*() const { + return *reinterpret_cast(m_data); + } + + TMember* operator->() const { + return reinterpret_cast(m_data); + } + + template + friend std::basic_ostream& operator<<(std::basic_ostream& out, const CollectionIterator& iter) { + return out << static_cast(iter.m_data); + } + + }; // class CollectionIterator + + template + class Collection : public Item { + + public: + + typedef CollectionIterator iterator; + typedef CollectionIterator const_iterator; + typedef TMember value_type; + + static constexpr osmium::item_type itemtype = TCollectionItemType; + + Collection() : + Item(sizeof(Collection), TCollectionItemType) { + } + + bool empty() const { + return sizeof(Collection) == byte_size(); + } + + iterator begin() { + return iterator(data() + sizeof(Collection)); + } + + iterator end() { + return iterator(data() + byte_size()); + } + + const_iterator cbegin() const { + return const_iterator(data() + sizeof(Collection)); + } + + const_iterator cend() const { + return const_iterator(data() + byte_size()); + } + + const_iterator begin() const { + return cbegin(); + } + + const_iterator end() const { + return cend(); + } + + }; // class Collection + + } // namespace memory + +} // namespace osmium + +#endif // OSMIUM_MEMORY_COLLECTION_HPP diff --git a/ThirdParty/osmium/memory/item.hpp b/ThirdParty/osmium/memory/item.hpp index 73e653efe..20bb75a7a 100644 --- a/ThirdParty/osmium/memory/item.hpp +++ b/ThirdParty/osmium/memory/item.hpp @@ -52,11 +52,11 @@ namespace osmium { // align datastructures to this many bytes constexpr item_size_type align_bytes = 8; - inline size_t padded_length(size_t length) { + inline size_t padded_length(size_t length) noexcept { return (length + align_bytes - 1) & ~(align_bytes - 1); } - inline item_size_type padded_length(item_size_type length) { + inline item_size_type padded_length(item_size_type length) noexcept { return (length + align_bytes - 1) & ~(align_bytes - 1); } @@ -85,15 +85,15 @@ namespace osmium { public: - unsigned char* data() { + unsigned char* data() noexcept { return reinterpret_cast(this); } - const unsigned char* data() const { + const unsigned char* data() const noexcept { return reinterpret_cast(this); } - }; + }; // class ItemHelper } // namespace detail @@ -112,22 +112,14 @@ namespace osmium { friend class osmium::builder::Builder; - unsigned char* next() { - return data() + padded_size(); - } - - const unsigned char* next() const { - return data() + padded_size(); - } - - Item& add_size(const item_size_type size) { + Item& add_size(const item_size_type size) noexcept { m_size += size; return *this; } protected: - explicit Item(item_size_type size=0, item_type type=item_type()) : + explicit Item(item_size_type size=0, item_type type=item_type()) noexcept : m_size(size), m_type(type), m_removed(false) { @@ -139,14 +131,22 @@ namespace osmium { Item& operator=(const Item&) = delete; Item& operator=(Item&&) = delete; - Item& type(const item_type item_type) { + Item& set_type(const item_type item_type) noexcept { m_type = item_type; return *this; } public: - item_size_type byte_size() const { + unsigned char* next() noexcept { + return data() + padded_size(); + } + + const unsigned char* next() const noexcept { + return data() + padded_size(); + } + + item_size_type byte_size() const noexcept { return m_size; } @@ -154,15 +154,15 @@ namespace osmium { return padded_length(m_size); } - item_type type() const { + item_type type() const noexcept { return m_type; } - bool removed() const { + bool removed() const noexcept { return m_removed; } - void removed(bool removed) { + void set_removed(bool removed) noexcept { m_removed = removed; } diff --git a/ThirdParty/osmium/memory/item_iterator.hpp b/ThirdParty/osmium/memory/item_iterator.hpp index 64899b333..34ed60083 100644 --- a/ThirdParty/osmium/memory/item_iterator.hpp +++ b/ThirdParty/osmium/memory/item_iterator.hpp @@ -1,181 +1,234 @@ -#ifndef OSMIUM_ITEM_ITERATOR_HPP -#define OSMIUM_ITEM_ITERATOR_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2014 Jochen Topf 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 -#include -#include -#include - -#include -#include -#include - -namespace osmium { - - namespace memory { - - namespace detail { - - template - inline bool type_is_compatible(osmium::item_type) { - return true; - } - - template <> - inline bool type_is_compatible(osmium::item_type t) { - return t == osmium::item_type::node; - } - - template <> - inline bool type_is_compatible(osmium::item_type t) { - return t == osmium::item_type::way; - } - - template <> - inline bool type_is_compatible(osmium::item_type t) { - return t == osmium::item_type::relation; - } - - template <> - inline bool type_is_compatible(osmium::item_type t) { - return t == osmium::item_type::area; - } - - template <> - inline bool type_is_compatible(osmium::item_type t) { - return t == osmium::item_type::changeset; - } - - template <> - inline bool type_is_compatible(osmium::item_type t) { - return t == osmium::item_type::node || t == osmium::item_type::way || t == osmium::item_type::relation || t == osmium::item_type::area; - } - - template <> - inline bool type_is_compatible(osmium::item_type t) { - return t == osmium::item_type::node || t == osmium::item_type::way || t == osmium::item_type::relation || t == osmium::item_type::area || t == osmium::item_type::changeset; - } - - } // namespace detail - - template - class ItemIterator : public std::iterator { - - static_assert(std::is_base_of::value, "TMember must derive from osmium::memory::Item"); - - // This data_type is either 'unsigned char*' or 'const unsigned char*' depending - // on whether TMember is const. This allows this class to be used as an iterator and - // as a const_iterator. - typedef typename std::conditional::value, const unsigned char*, unsigned char*>::type data_type; - - data_type m_data; - data_type m_end; - - void advance_to_next_item_of_right_type() { - while (m_data != m_end && - !detail::type_is_compatible::type>(reinterpret_cast(m_data)->type())) { - m_data = reinterpret_cast(m_data)->next(); - } - } - - public: - - ItemIterator() : - m_data(nullptr), - m_end(nullptr) { - } - - ItemIterator(data_type data, data_type end) : - m_data(data), - m_end(end) { - advance_to_next_item_of_right_type(); - } - - ItemIterator& operator++() { - assert(m_data); - assert(m_data != m_end); - m_data = reinterpret_cast(m_data)->next(); - advance_to_next_item_of_right_type(); - return *static_cast*>(this); - } - - ItemIterator operator++(int) { - ItemIterator tmp(*this); - operator++(); - return tmp; - } - - bool operator==(const ItemIterator& rhs) const { - return m_data == rhs.m_data && m_end == rhs.m_end; - } - - bool operator!=(const ItemIterator& rhs) const { - return !(*this == rhs); - } - - unsigned char* data() const { - assert(m_data); - assert(m_data != m_end); - return m_data; - } - - TMember& operator*() const { - assert(m_data); - assert(m_data != m_end); - return *reinterpret_cast(m_data); - } - - TMember* operator->() const { - assert(m_data); - assert(m_data != m_end); - return reinterpret_cast(m_data); - } - - explicit operator bool() const { - return m_data != nullptr; - } - - template - friend std::basic_ostream& operator<<(std::basic_ostream& out, const ItemIterator& iter) { - return out << static_cast(iter.m_data); - } - - }; // class ItemIterator - - } // namespace memory - -} // namespace osmium - -#endif // OSMIUM_ITEM_ITERATOR_HPP +#ifndef OSMIUM_ITEM_ITERATOR_HPP +#define OSMIUM_ITEM_ITERATOR_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2014 Jochen Topf 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 +#include +#include +#include + +#include +#include + +namespace osmium { + + class Node; + class Way; + class Relation; + class Area; + class Changeset; + class OSMObject; + class OSMEntity; + class TagList; + class WayNodeList; + class RelationMemberList; + class InnerRing; + class OuterRing; + + namespace memory { + + namespace detail { + + template + inline bool type_is_compatible(osmium::item_type) noexcept { + return true; + } + + template <> + inline bool type_is_compatible(osmium::item_type t) noexcept { + return t == osmium::item_type::node; + } + + template <> + inline bool type_is_compatible(osmium::item_type t) noexcept { + return t == osmium::item_type::way; + } + + template <> + inline bool type_is_compatible(osmium::item_type t) noexcept { + return t == osmium::item_type::relation; + } + + template <> + inline bool type_is_compatible(osmium::item_type t) noexcept { + return t == osmium::item_type::area; + } + + template <> + inline bool type_is_compatible(osmium::item_type t) noexcept { + return t == osmium::item_type::changeset; + } + + template <> + inline bool type_is_compatible(osmium::item_type t) noexcept { + return t == osmium::item_type::node || t == osmium::item_type::way || t == osmium::item_type::relation || t == osmium::item_type::area; + } + + template <> + inline bool type_is_compatible(osmium::item_type t) noexcept { + return t == osmium::item_type::node || t == osmium::item_type::way || t == osmium::item_type::relation || t == osmium::item_type::area || t == osmium::item_type::changeset; + } + + template <> + inline bool type_is_compatible(osmium::item_type t) noexcept { + return t == osmium::item_type::tag_list; + } + + template <> + inline bool type_is_compatible(osmium::item_type t) noexcept { + return t == osmium::item_type::way_node_list; + } + + template <> + inline bool type_is_compatible(osmium::item_type t) noexcept { + return t == osmium::item_type::relation_member_list || t == osmium::item_type::relation_member_list_with_full_members; + } + + template <> + inline bool type_is_compatible(osmium::item_type t) noexcept { + return t == osmium::item_type::outer_ring; + } + + template <> + inline bool type_is_compatible(osmium::item_type t) noexcept { + return t == osmium::item_type::inner_ring; + } + + } // namespace detail + + template + class ItemIterator : public std::iterator { + + static_assert(std::is_base_of::value, "TMember must derive from osmium::memory::Item"); + + // This data_type is either 'unsigned char*' or 'const unsigned char*' depending + // on whether TMember is const. This allows this class to be used as an iterator and + // as a const_iterator. + typedef typename std::conditional::value, const unsigned char*, unsigned char*>::type data_type; + + data_type m_data; + data_type m_end; + + void advance_to_next_item_of_right_type() { + while (m_data != m_end && + !detail::type_is_compatible::type>(reinterpret_cast(m_data)->type())) { + m_data = reinterpret_cast(m_data)->next(); + } + } + + public: + + ItemIterator() noexcept : + m_data(nullptr), + m_end(nullptr) { + } + + ItemIterator(data_type data, data_type end) : + m_data(data), + m_end(end) { + advance_to_next_item_of_right_type(); + } + + template + ItemIterator cast() const { + return ItemIterator(m_data, m_end); + } + + ItemIterator& operator++() { + assert(m_data); + assert(m_data != m_end); + m_data = reinterpret_cast(m_data)->next(); + advance_to_next_item_of_right_type(); + return *static_cast*>(this); + } + + /** + * Like operator++() but will NOT skip items of unwanted + * types. Do not use this unless you know what you are + * doing. + */ + ItemIterator& advance_once() { + assert(m_data); + assert(m_data != m_end); + m_data = reinterpret_cast(m_data)->next(); + return *static_cast*>(this); + } + + ItemIterator operator++(int) { + ItemIterator tmp(*this); + operator++(); + return tmp; + } + + bool operator==(const ItemIterator& rhs) const { + return m_data == rhs.m_data && m_end == rhs.m_end; + } + + bool operator!=(const ItemIterator& rhs) const { + return !(*this == rhs); + } + + unsigned char* data() const { + assert(m_data); + return m_data; + } + + TMember& operator*() const { + assert(m_data); + assert(m_data != m_end); + return *reinterpret_cast(m_data); + } + + TMember* operator->() const { + assert(m_data); + assert(m_data != m_end); + return reinterpret_cast(m_data); + } + + explicit operator bool() const { + return m_data != nullptr; + } + + template + friend std::basic_ostream& operator<<(std::basic_ostream& out, const ItemIterator& iter) { + return out << static_cast(iter.m_data); + } + + }; // class ItemIterator + + } // namespace memory + +} // namespace osmium + +#endif // OSMIUM_ITEM_ITERATOR_HPP diff --git a/ThirdParty/osmium/object_pointer_collection.hpp b/ThirdParty/osmium/object_pointer_collection.hpp index 08ea46e01..22029a149 100644 --- a/ThirdParty/osmium/object_pointer_collection.hpp +++ b/ThirdParty/osmium/object_pointer_collection.hpp @@ -1,112 +1,112 @@ -#ifndef OSMIUM_OBJECT_POINTER_COLLECTION_HPP -#define OSMIUM_OBJECT_POINTER_COLLECTION_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 -#include -#include - -#include - -#include -#include -#include - -// IWYU pragma: no_forward_declare osmium::OSMObject -// IWYU pragma: no_forward_declare osmium::memory::Item - -namespace osmium { - - /** - * A collection of pointers to OSM objects. The pointers can be easily - * and quickly sorted or otherwise manipulated, while the objects - * themselves or the buffers they are in, do not have to be changed. - * - * An iterator is provided that can iterate over the pointers but looks - * like it is iterating over the underlying OSM objects. - * - * This class implements the visitor pattern which makes it easy to - * populate the collection from a buffer of OSM objects: - * - * osmium::ObjectPointerCollection objects; - * osmium::memory::Buffer buffer = reader.read(); - * osmium::apply(buffer, objects); - * - */ - class ObjectPointerCollection : public osmium::handler::Handler { - - std::vector m_objects; - - public: - - typedef boost::indirect_iterator::iterator, osmium::OSMObject> iterator; - typedef boost::indirect_iterator::const_iterator, const osmium::OSMObject> const_iterator; - - ObjectPointerCollection() : - m_objects() { - } - - void osm_object(osmium::OSMObject& object) { - m_objects.push_back(&object); - } - - /** - * Sort objects according to the given order functor. - */ - template - void sort(TCompare&& compare) { - std::sort(m_objects.begin(), m_objects.end(), std::forward(compare)); - } - - iterator begin() { - return iterator { m_objects.begin() }; - } - - iterator end() { - return iterator { m_objects.end() }; - } - - const_iterator cbegin() const { - return const_iterator { m_objects.cbegin() }; - } - - const_iterator cend() const { - return const_iterator { m_objects.cend() }; - } - - }; // class ObjectPointerCollection - -} // namespace osmium - -#endif // OSMIUM_OBJECT_POINTER_COLLECTION_HPP +#ifndef OSMIUM_OBJECT_POINTER_COLLECTION_HPP +#define OSMIUM_OBJECT_POINTER_COLLECTION_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include + +#include + +#include +#include +#include + +// IWYU pragma: no_forward_declare osmium::OSMObject +// IWYU pragma: no_forward_declare osmium::memory::Item + +namespace osmium { + + /** + * A collection of pointers to OSM objects. The pointers can be easily + * and quickly sorted or otherwise manipulated, while the objects + * themselves or the buffers they are in, do not have to be changed. + * + * An iterator is provided that can iterate over the pointers but looks + * like it is iterating over the underlying OSM objects. + * + * This class implements the visitor pattern which makes it easy to + * populate the collection from a buffer of OSM objects: + * + * osmium::ObjectPointerCollection objects; + * osmium::memory::Buffer buffer = reader.read(); + * osmium::apply(buffer, objects); + * + */ + class ObjectPointerCollection : public osmium::handler::Handler { + + std::vector m_objects; + + public: + + typedef boost::indirect_iterator::iterator, osmium::OSMObject> iterator; + typedef boost::indirect_iterator::const_iterator, const osmium::OSMObject> const_iterator; + + ObjectPointerCollection() noexcept : + m_objects() { + } + + void osm_object(osmium::OSMObject& object) { + m_objects.push_back(&object); + } + + /** + * Sort objects according to the given order functor. + */ + template + void sort(TCompare&& compare) { + std::sort(m_objects.begin(), m_objects.end(), std::forward(compare)); + } + + iterator begin() { + return iterator { m_objects.begin() }; + } + + iterator end() { + return iterator { m_objects.end() }; + } + + const_iterator cbegin() const { + return const_iterator { m_objects.cbegin() }; + } + + const_iterator cend() const { + return const_iterator { m_objects.cend() }; + } + + }; // class ObjectPointerCollection + +} // namespace osmium + +#endif // OSMIUM_OBJECT_POINTER_COLLECTION_HPP diff --git a/ThirdParty/osmium/osm/area.hpp b/ThirdParty/osmium/osm/area.hpp index 5d8233de9..a388de2e9 100644 --- a/ThirdParty/osmium/osm/area.hpp +++ b/ThirdParty/osmium/osm/area.hpp @@ -33,6 +33,7 @@ DEALINGS IN THE SOFTWARE. */ +#include #include #include @@ -123,7 +124,7 @@ namespace osmium { * Was this area created from a way? (In contrast to areas * created from a relation and their members.) */ - bool from_way() const { + bool from_way() const noexcept { return (positive_id() & 0x1) == 0; } @@ -148,7 +149,19 @@ namespace osmium { case osmium::item_type::inner_ring: ++counter.second; break; - default: + case osmium::item_type::tag_list: + // ignore tags + break; + case osmium::item_type::undefined: + case osmium::item_type::node: + case osmium::item_type::way: + case osmium::item_type::relation: + case osmium::item_type::area: + case osmium::item_type::changeset: + case osmium::item_type::way_node_list: + case osmium::item_type::relation_member_list: + case osmium::item_type::relation_member_list_with_full_members: + assert(false && "Children of Area can only be outer/inner_ring and tag_list."); break; } } @@ -163,6 +176,14 @@ namespace osmium { return num_rings().first > 1; } + osmium::memory::ItemIterator inner_ring_cbegin(const osmium::memory::ItemIterator& it) const { + return it.cast(); + } + + osmium::memory::ItemIterator inner_ring_cend(const osmium::memory::ItemIterator& it) const { + return std::next(it).cast(); + } + }; // class Area static_assert(sizeof(Area) % osmium::memory::align_bytes == 0, "Class osmium::Area has wrong size to be aligned properly!"); diff --git a/ThirdParty/osmium/osm/box.hpp b/ThirdParty/osmium/osm/box.hpp index fea0c70cd..2b761fefc 100644 --- a/ThirdParty/osmium/osm/box.hpp +++ b/ThirdParty/osmium/osm/box.hpp @@ -54,7 +54,7 @@ namespace osmium { * Create undefined Box. Use the extend() function * to add actual bounds. */ - constexpr Box() : + constexpr Box() noexcept : m_bottom_left(), m_top_right() { } @@ -83,16 +83,16 @@ namespace osmium { if (location) { if (m_bottom_left) { if (location.x() < m_bottom_left.x()) { - m_bottom_left.x(location.x()); + m_bottom_left.set_x(location.x()); } if (location.x() > m_top_right.x()) { - m_top_right.x(location.x()); + m_top_right.set_x(location.x()); } if (location.y() < m_bottom_left.y()) { - m_bottom_left.y(location.y()); + m_bottom_left.set_y(location.y()); } if (location.y() > m_top_right.y()) { - m_top_right.y(location.y()); + m_top_right.set_y(location.y()); } } else { m_bottom_left = location; diff --git a/ThirdParty/osmium/osm/changeset.hpp b/ThirdParty/osmium/osm/changeset.hpp index e04267cb1..2b79fb5cf 100644 --- a/ThirdParty/osmium/osm/changeset.hpp +++ b/ThirdParty/osmium/osm/changeset.hpp @@ -52,8 +52,11 @@ namespace osmium { } /** - * An OSM Changeset is of a group of changes made by a single user over a - * short period of time. + * \brief An OSM Changeset, a group of changes made by a single user over + * a short period of time. + * + * You can not create Changeset objects directly. Use the ChangesetBuilder + * class to create Changesets in a Buffer. */ class Changeset : public osmium::OSMEntity { @@ -71,7 +74,7 @@ namespace osmium { OSMEntity(sizeof(Changeset), osmium::item_type::changeset) { } - void user_size(string_size_type size) { + void set_user_size(string_size_type size) { m_user_size = size; } @@ -83,30 +86,6 @@ namespace osmium { return data() + osmium::memory::padded_length(sizeof(Changeset) + m_user_size); } - template - T& subitem_of_type() { - for (iterator it = begin(); it != end(); ++it) { - if (it->type() == T::itemtype) { - return reinterpret_cast(*it); - } - } - - static T subitem; - return subitem; - } - - template - const T& subitem_of_type() const { - for (const_iterator it = cbegin(); it != cend(); ++it) { - if (it->type() == T::itemtype) { - return reinterpret_cast(*it); - } - } - - static const T subitem; - return subitem; - } - public: /// Get ID of this changeset @@ -117,9 +96,10 @@ namespace osmium { /** * Set ID of this changeset * - * @return Reference to changeset to make calls chainable. + * @param id The id. + * @returns Reference to changeset to make calls chainable. */ - Changeset& id(changeset_id_type id) noexcept { + Changeset& set_id(changeset_id_type id) noexcept { m_id = id; return *this; } @@ -127,10 +107,11 @@ namespace osmium { /** * Set ID of this changeset. * - * @return Reference to object to make calls chainable. + * @param id The id. + * @returns Reference to object to make calls chainable. */ - Changeset& id(const char* id) { - return this->id(osmium::string_to_changeset_id(id)); + Changeset& set_id(const char* id) { + return set_id(osmium::string_to_changeset_id(id)); } /// Get user id. @@ -141,31 +122,34 @@ namespace osmium { /** * Set user id. * - * @return Reference to changeset to make calls chainable. + * @param uid The user id. + * @returns Reference to changeset to make calls chainable. */ - Changeset& uid(user_id_type uid) noexcept { + Changeset& set_uid(user_id_type uid) noexcept { m_uid = uid; return *this; } /** - * Set user id. - * Sets uid to 0 (anonymous) if the given uid is smaller than 0. + * Set user id to given uid or to 0 (anonymous user) if the given + * uid is smaller than 0. * - * @return Reference to changeset to make calls chainable. + * @param uid The user id. + * @returns Reference to changeset to make calls chainable. */ - Changeset& uid_from_signed(signed_user_id_type uid) noexcept { + Changeset& set_uid_from_signed(signed_user_id_type uid) noexcept { m_uid = uid < 0 ? 0 : static_cast(uid); return *this; } /** - * Set user id. + * Set user id to given uid or to 0 (anonymous user) if the given + * uid is smaller than 0. * - * @return Reference to changeset to make calls chainable. + * @returns Reference to changeset to make calls chainable. */ - Changeset& uid(const char* uid) { - return this->uid_from_signed(string_to_user_id(uid)); + Changeset& set_uid(const char* uid) { + return set_uid_from_signed(string_to_user_id(uid)); } /// Is this user anonymous? @@ -181,17 +165,19 @@ namespace osmium { /** * Get timestamp when this changeset was closed. * - * This will return the empty Timestamp when the - * changeset is not yet closed. + * @returns Timestamp. Will return the empty Timestamp when the + * changeset is not yet closed. */ osmium::Timestamp closed_at() const noexcept { return m_closed_at; } + /// Is this changeset open? bool open() const noexcept { return m_closed_at == osmium::Timestamp(); } + /// Is this changeset closed? bool closed() const noexcept { return !open(); } @@ -200,9 +186,9 @@ namespace osmium { * Set the timestamp when this changeset was created. * * @param timestamp Timestamp - * @return Reference to changeset to make calls chainable. + * @returns Reference to changeset to make calls chainable. */ - Changeset& created_at(const osmium::Timestamp timestamp) { + Changeset& set_created_at(const osmium::Timestamp timestamp) { m_created_at = timestamp; return *this; } @@ -211,30 +197,43 @@ namespace osmium { * Set the timestamp when this changeset was closed. * * @param timestamp Timestamp - * @return Reference to changeset to make calls chainable. + * @returns Reference to changeset to make calls chainable. */ - Changeset& closed_at(const osmium::Timestamp timestamp) { + Changeset& set_closed_at(const osmium::Timestamp timestamp) { m_closed_at = timestamp; return *this; } + /// Get the number of changes in this changeset num_changes_type num_changes() const noexcept { return m_num_changes; } - Changeset& num_changes(num_changes_type num_changes) noexcept { + /// Set the number of changes in this changeset + Changeset& set_num_changes(num_changes_type num_changes) noexcept { m_num_changes = num_changes; return *this; } - Changeset& num_changes(const char* num_changes) noexcept { - return this->num_changes(osmium::string_to_num_changes(num_changes)); + /// Set the number of changes in this changeset + Changeset& set_num_changes(const char* num_changes) noexcept { + return set_num_changes(osmium::string_to_num_changes(num_changes)); } + /** + * Get the bounding box of this changeset. + * + * @returns Bounding box. Can be empty. + */ osmium::Box& bounds() noexcept { return m_bounds; } + /** + * Get the bounding box of this changeset. + * + * @returns Bounding box. Can be empty. + */ const osmium::Box& bounds() const noexcept { return m_bounds; } @@ -244,33 +243,29 @@ namespace osmium { return reinterpret_cast(data() + sizeof(Changeset)); } - /// Get the list of tags. - TagList& tags() { - return subitem_of_type(); - } - /// Get the list of tags. const TagList& tags() const { - return subitem_of_type(); + return osmium::detail::subitem_of_type(cbegin(), cend()); } /** * Set named attribute. * - * @param attr Name of the attribute (must be one of "id", "version", "changeset", "timestamp", "uid", "visible") + * @param attr Name of the attribute (must be one of "id", "version", + * "changeset", "timestamp", "uid", "visible") * @param value Value of the attribute */ void set_attribute(const char* attr, const char* value) { if (!strcmp(attr, "id")) { - id(value); + set_id(value); } else if (!strcmp(attr, "num_changes")) { - num_changes(value); + set_num_changes(value); } else if (!strcmp(attr, "created_at")) { - created_at(osmium::Timestamp(value)); + set_created_at(osmium::Timestamp(value)); } else if (!strcmp(attr, "closed_at")) { - closed_at(osmium::Timestamp(value)); + set_closed_at(osmium::Timestamp(value)); } else if (!strcmp(attr, "uid")) { - uid(value); + set_uid(value); } } @@ -303,7 +298,8 @@ namespace osmium { }; // class Changeset - static_assert(sizeof(Changeset) % osmium::memory::align_bytes == 0, "Class osmium::Changeset has wrong size to be aligned properly!"); + static_assert(sizeof(Changeset) % osmium::memory::align_bytes == 0, + "Class osmium::Changeset has wrong size to be aligned properly!"); /** * Changesets are equal if their IDs are equal. diff --git a/ThirdParty/osmium/osm/diff_object.hpp b/ThirdParty/osmium/osm/diff_object.hpp index d3d9c2123..4aecb8cfd 100644 --- a/ThirdParty/osmium/osm/diff_object.hpp +++ b/ThirdParty/osmium/osm/diff_object.hpp @@ -1,156 +1,156 @@ -#ifndef OSMIUM_OSM_DIFF_OBJECT_HPP -#define OSMIUM_OSM_DIFF_OBJECT_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 -#include -#include -#include - -namespace osmium { - - class Node; - class Way; - class Relation; - - class DiffObject { - - protected: - - osmium::OSMObject* m_prev; - osmium::OSMObject* m_curr; - osmium::OSMObject* m_next; - - public: - - DiffObject() : - m_prev(nullptr), - m_curr(nullptr), - m_next(nullptr) { - } - - explicit DiffObject(osmium::OSMObject& prev, osmium::OSMObject& curr, osmium::OSMObject& next) : - m_prev(&prev), - m_curr(&curr), - m_next(&next) { - } - - DiffObject(const DiffObject& other) = default; - DiffObject& operator=(const DiffObject& other) = default; - - DiffObject(DiffObject&& other) = default; - DiffObject& operator=(DiffObject&& other) = default; - - const osmium::OSMObject& prev() const { - return *m_prev; - } - - const osmium::OSMObject& curr() const { - return *m_curr; - } - - const osmium::OSMObject& next() const { - return *m_next; - } - - bool first() const { - return m_prev == m_curr; - } - - bool last() const { - return m_curr == m_next; - } - - osmium::item_type type() const { - return m_curr->type(); - } - - osmium::object_id_type id() const { - return m_curr->id(); - } - - osmium::object_version_type version() const { - return m_curr->version(); - } - - osmium::changeset_id_type changeset() const { - return m_curr->changeset(); - } - - const osmium::Timestamp start_time() const { - return m_curr->timestamp(); - } - - const osmium::Timestamp end_time() const { - return last() ? osmium::Timestamp() : m_next->timestamp(); - } - - }; // class DiffObject - - template - class DiffObjectDerived : public DiffObject { - - public: - - DiffObjectDerived(T& prev, T& curr, T& next) : - DiffObject(prev, curr, next) { - } - - DiffObjectDerived(const DiffObjectDerived& other) = default; - DiffObjectDerived& operator=(const DiffObjectDerived& other) = default; - - DiffObjectDerived(DiffObjectDerived&& other) = default; - DiffObjectDerived& operator=(DiffObjectDerived&& other) = default; - - const T& prev() const { - return *static_cast(m_prev); - } - - const T& curr() const { - return *static_cast(m_curr); - } - - const T& next() const { - return *static_cast(m_next); - } - - }; // class DiffObjectDerived - - typedef DiffObjectDerived DiffNode; - typedef DiffObjectDerived DiffWay; - typedef DiffObjectDerived DiffRelation; - -} // namespace osmium - -#endif // OSMIUM_OSM_DIFF_OBJECT_HPP +#ifndef OSMIUM_OSM_DIFF_OBJECT_HPP +#define OSMIUM_OSM_DIFF_OBJECT_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include + +namespace osmium { + + class Node; + class Way; + class Relation; + + class DiffObject { + + protected: + + osmium::OSMObject* m_prev; + osmium::OSMObject* m_curr; + osmium::OSMObject* m_next; + + public: + + DiffObject() noexcept : + m_prev(nullptr), + m_curr(nullptr), + m_next(nullptr) { + } + + explicit DiffObject(osmium::OSMObject& prev, osmium::OSMObject& curr, osmium::OSMObject& next) noexcept : + m_prev(&prev), + m_curr(&curr), + m_next(&next) { + } + + DiffObject(const DiffObject& other) = default; + DiffObject& operator=(const DiffObject& other) = default; + + DiffObject(DiffObject&& other) = default; + DiffObject& operator=(DiffObject&& other) = default; + + const osmium::OSMObject& prev() const noexcept { + return *m_prev; + } + + const osmium::OSMObject& curr() const noexcept { + return *m_curr; + } + + const osmium::OSMObject& next() const noexcept { + return *m_next; + } + + bool first() const noexcept { + return m_prev == m_curr; + } + + bool last() const noexcept { + return m_curr == m_next; + } + + osmium::item_type type() const noexcept { + return m_curr->type(); + } + + osmium::object_id_type id() const noexcept { + return m_curr->id(); + } + + osmium::object_version_type version() const noexcept { + return m_curr->version(); + } + + osmium::changeset_id_type changeset() const noexcept { + return m_curr->changeset(); + } + + const osmium::Timestamp start_time() const noexcept { + return m_curr->timestamp(); + } + + const osmium::Timestamp end_time() const noexcept { + return last() ? osmium::Timestamp() : m_next->timestamp(); + } + + }; // class DiffObject + + template + class DiffObjectDerived : public DiffObject { + + public: + + DiffObjectDerived(T& prev, T& curr, T& next) noexcept : + DiffObject(prev, curr, next) { + } + + DiffObjectDerived(const DiffObjectDerived& other) = default; + DiffObjectDerived& operator=(const DiffObjectDerived& other) = default; + + DiffObjectDerived(DiffObjectDerived&& other) = default; + DiffObjectDerived& operator=(DiffObjectDerived&& other) = default; + + const T& prev() const noexcept { + return *static_cast(m_prev); + } + + const T& curr() const noexcept { + return *static_cast(m_curr); + } + + const T& next() const noexcept { + return *static_cast(m_next); + } + + }; // class DiffObjectDerived + + typedef DiffObjectDerived DiffNode; + typedef DiffObjectDerived DiffWay; + typedef DiffObjectDerived DiffRelation; + +} // namespace osmium + +#endif // OSMIUM_OSM_DIFF_OBJECT_HPP diff --git a/ThirdParty/osmium/osm/entity.hpp b/ThirdParty/osmium/osm/entity.hpp index 9d068f587..e37ed4c94 100644 --- a/ThirdParty/osmium/osm/entity.hpp +++ b/ThirdParty/osmium/osm/entity.hpp @@ -1,55 +1,74 @@ -#ifndef OSMIUM_OSM_ENTITY_HPP -#define OSMIUM_OSM_ENTITY_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 - -namespace osmium { - - /** - * OSMEntity is the parent class for the OSMObject class and the Changeset class. - */ - class OSMEntity : public osmium::memory::Item { - - public: - - explicit OSMEntity(osmium::memory::item_size_type size, osmium::item_type type) : - Item(size, type) { - } - - }; // class OSMEntity - -} // namespace osmium - -#endif // OSMIUM_OSM_ENTITY_HPP +#ifndef OSMIUM_OSM_ENTITY_HPP +#define OSMIUM_OSM_ENTITY_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 + +namespace osmium { + + namespace detail { + + template + inline TSubitem& subitem_of_type(TIter it, TIter end) { + for (; it != end; ++it) { + if (it->type() == TSubitem::itemtype) { + return reinterpret_cast(*it); + } + } + + // If no subitem of the TSubitem type was found, + // return a default constructed one. + static TSubitem subitem; + return subitem; + } + + } // namespace detail + + /** + * \brief OSMEntity is the abstract base class for the OSMObject and + * Changeset classes. + */ + class OSMEntity : public osmium::memory::Item { + + public: + + explicit OSMEntity(osmium::memory::item_size_type size, osmium::item_type type) : + Item(size, type) { + } + + }; // class OSMEntity + +} // namespace osmium + +#endif // OSMIUM_OSM_ENTITY_HPP diff --git a/ThirdParty/osmium/osm/entity_bits.hpp b/ThirdParty/osmium/osm/entity_bits.hpp index d6e4a8b75..96d44ab2e 100644 --- a/ThirdParty/osmium/osm/entity_bits.hpp +++ b/ThirdParty/osmium/osm/entity_bits.hpp @@ -68,20 +68,20 @@ namespace osmium { }; // enum type - inline type operator|(const type lhs, const type rhs) { + inline type operator|(const type lhs, const type rhs) noexcept { return static_cast(static_cast(lhs) | static_cast (rhs)); } - inline type& operator|=(type& lhs, const type rhs) { + inline type& operator|=(type& lhs, const type rhs) noexcept { lhs = lhs | rhs; return lhs; } - inline type operator&(const type lhs, const type rhs) { + inline type operator&(const type lhs, const type rhs) noexcept { return static_cast(static_cast(lhs) & static_cast (rhs)); } - inline type operator&=(type& lhs, const type rhs) { + inline type operator&=(type& lhs, const type rhs) noexcept { lhs = lhs & rhs; return lhs; } diff --git a/ThirdParty/osmium/osm/item_type.hpp b/ThirdParty/osmium/osm/item_type.hpp index 90075d331..d277e06c8 100644 --- a/ThirdParty/osmium/osm/item_type.hpp +++ b/ThirdParty/osmium/osm/item_type.hpp @@ -56,7 +56,7 @@ namespace osmium { }; // enum class item_type - inline item_type char_to_item_type(const char c) { + inline item_type char_to_item_type(const char c) noexcept { switch (c) { case 'X': return item_type::undefined; @@ -87,7 +87,10 @@ namespace osmium { } } - inline char item_type_to_char(const item_type type) { +// avoid g++ false positive +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wreturn-type" + inline char item_type_to_char(const item_type type) noexcept { switch (type) { case item_type::undefined: return 'X'; @@ -116,7 +119,7 @@ namespace osmium { } } - inline const char* item_type_to_name(const item_type type) { + inline const char* item_type_to_name(const item_type type) noexcept { switch (type) { case item_type::undefined: return "undefined"; @@ -144,12 +147,19 @@ namespace osmium { return "inner_ring"; } } +#pragma GCC diagnostic pop template inline std::basic_ostream& operator<<(std::basic_ostream& out, const item_type item_type) { return out << item_type_to_char(item_type); } + /** + * This exception is thrown when a visitor encounters an unknown item type. + * Under usual circumstance this should not happen. If it does happen, it + * probably means the buffer contains different kinds of objects than were + * expected or that there is some kind of data corruption. + */ struct unknown_type : public std::runtime_error { unknown_type() : diff --git a/ThirdParty/osmium/osm/location.hpp b/ThirdParty/osmium/osm/location.hpp index 8884583ad..cabecd50f 100644 --- a/ThirdParty/osmium/osm/location.hpp +++ b/ThirdParty/osmium/osm/location.hpp @@ -33,19 +33,16 @@ DEALINGS IN THE SOFTWARE. */ -#include -#include #include #include -#include #include -#include #include #include #include #include +#include namespace osmium { @@ -86,7 +83,7 @@ namespace osmium { public: - /// this value is used for a coordinate to mark it as undefined + // this value is used for a coordinate to mark it as undefined // MSVC doesn't declare std::numeric_limits::max() as // constexpr, so we hard code this for the time being. // static constexpr int32_t undefined_coordinate = std::numeric_limits::max(); @@ -105,7 +102,7 @@ namespace osmium { /** * Create undefined Location. */ - explicit constexpr Location() : + explicit constexpr Location() noexcept : m_x(undefined_coordinate), m_y(undefined_coordinate) { } @@ -115,7 +112,7 @@ namespace osmium { * Note that these coordinates are coordinate_precision * times larger than the real coordinates. */ - constexpr Location(const int32_t x, const int32_t y) : + constexpr Location(const int32_t x, const int32_t y) noexcept : m_x(x), m_y(y) { } @@ -125,7 +122,7 @@ namespace osmium { * Note that these coordinates are coordinate_precision * times larger than the real coordinates. */ - constexpr Location(const int64_t x, const int64_t y) : + constexpr Location(const int64_t x, const int64_t y) noexcept : m_x(static_cast(x)), m_y(static_cast(y)) { } @@ -171,12 +168,12 @@ namespace osmium { return m_y; } - Location& x(const int32_t x) noexcept { + Location& set_x(const int32_t x) noexcept { m_x = x; return *this; } - Location& y(const int32_t y) noexcept { + Location& set_y(const int32_t y) noexcept { m_y = y; return *this; } @@ -219,44 +216,21 @@ namespace osmium { return fix_to_double(m_y); } - Location& lon(double lon) noexcept { + Location& set_lon(double lon) noexcept { m_x = double_to_fix(lon); return *this; } - Location& lat(double lat) noexcept { + Location& set_lat(double lat) noexcept { m_y = double_to_fix(lat); return *this; } - static constexpr int coordinate_length = - 1 + /* sign */ - 3 + /* before . */ - 1 + /* . */ - 7 + /* after . */ - 1; /* null byte */ - - template - static T coordinate2string(T iterator, double value) { - char buffer[coordinate_length]; - -#ifndef _MSC_VER - int len = snprintf(buffer, coordinate_length, "%.7f", value); -#else - int len = _snprintf(buffer, coordinate_length, "%.7f", value); -#endif - assert(len > 0 && len < coordinate_length); - while (buffer[len-1] == '0') --len; - if (buffer[len-1] == '.') --len; - - return std::copy_n(buffer, len, iterator); - } - template T as_string(T iterator, const char separator) const { - iterator = coordinate2string(iterator, lon()); + iterator = osmium::util::double2string(iterator, lon(), 7); *iterator++ = separator; - return coordinate2string(iterator, lat()); + return osmium::util::double2string(iterator, lat(), 7); } }; // class Location @@ -268,7 +242,7 @@ namespace osmium { return lhs.x() == rhs.x() && lhs.y() == rhs.y(); } - inline OSMIUM_CONSTEXPR bool operator!=(const Location& lhs, const Location& rhs) { + inline OSMIUM_CONSTEXPR bool operator!=(const Location& lhs, const Location& rhs) noexcept { return ! (lhs == rhs); } @@ -281,15 +255,15 @@ namespace osmium { return (lhs.x() == rhs.x() && lhs.y() < rhs.y()) || lhs.x() < rhs.x(); } - inline OSMIUM_CONSTEXPR bool operator>(const Location& lhs, const Location& rhs) { + inline OSMIUM_CONSTEXPR bool operator>(const Location& lhs, const Location& rhs) noexcept { return rhs < lhs; } - inline OSMIUM_CONSTEXPR bool operator<=(const Location& lhs, const Location& rhs) { + inline OSMIUM_CONSTEXPR bool operator<=(const Location& lhs, const Location& rhs) noexcept { return ! (rhs < lhs); } - inline OSMIUM_CONSTEXPR bool operator>=(const Location& lhs, const Location& rhs) { + inline OSMIUM_CONSTEXPR bool operator>=(const Location& lhs, const Location& rhs) noexcept { return ! (lhs < rhs); } diff --git a/ThirdParty/osmium/osm/node.hpp b/ThirdParty/osmium/osm/node.hpp index e1bc2d0eb..50146c568 100644 --- a/ThirdParty/osmium/osm/node.hpp +++ b/ThirdParty/osmium/osm/node.hpp @@ -58,15 +58,11 @@ namespace osmium { static constexpr osmium::item_type itemtype = osmium::item_type::node; - const osmium::Location location() const { + osmium::Location location() const noexcept { return m_location; } - osmium::Location& location() { - return m_location; - } - - Node& location(const osmium::Location& location) { + Node& set_location(const osmium::Location& location) { m_location = location; return *this; } diff --git a/ThirdParty/osmium/osm/node_ref.hpp b/ThirdParty/osmium/osm/node_ref.hpp index 5e10b0ab6..ed50b9e66 100644 --- a/ThirdParty/osmium/osm/node_ref.hpp +++ b/ThirdParty/osmium/osm/node_ref.hpp @@ -54,20 +54,27 @@ namespace osmium { public: - NodeRef(const osmium::object_id_type ref=0, const osmium::Location& location=Location()) : + NodeRef(const osmium::object_id_type ref=0, const osmium::Location& location=Location()) noexcept : m_ref(ref), m_location(location) { } - osmium::object_id_type ref() const { + osmium::object_id_type ref() const noexcept { return m_ref; } - osmium::unsigned_object_id_type positive_ref() const { + osmium::unsigned_object_id_type positive_ref() const noexcept { return static_cast(std::abs(m_ref)); } - osmium::Location location() const { + /** + * Get reference to location in this NodeRef. Can be used to update it. + */ + osmium::Location& location() noexcept { + return m_location; + } + + osmium::Location location() const noexcept { return m_location; } @@ -79,33 +86,47 @@ namespace osmium { return m_location.lat(); } - void location(const osmium::Location& location) { + int32_t x() const noexcept { + return m_location.x(); + } + + int32_t y() const noexcept { + return m_location.y(); + } + + NodeRef& set_ref(const osmium::object_id_type ref) noexcept { + m_ref = ref; + return *this; + } + + NodeRef& set_location(const osmium::Location& location) noexcept { m_location = location; + return *this; } }; // class NodeRef - inline bool operator==(const NodeRef& lhs, const NodeRef& rhs) { + inline bool operator==(const NodeRef& lhs, const NodeRef& rhs) noexcept { return lhs.ref() == rhs.ref(); } - inline bool operator!=(const NodeRef& lhs, const NodeRef& rhs) { + inline bool operator!=(const NodeRef& lhs, const NodeRef& rhs) noexcept { return ! (lhs == rhs); } - inline bool operator<(const NodeRef& lhs, const NodeRef& rhs) { + inline bool operator<(const NodeRef& lhs, const NodeRef& rhs) noexcept { return lhs.ref() < rhs.ref(); } - inline bool operator>(const NodeRef& lhs, const NodeRef& rhs) { + inline bool operator>(const NodeRef& lhs, const NodeRef& rhs) noexcept { return rhs < lhs; } - inline bool operator<=(const NodeRef& lhs, const NodeRef& rhs) { + inline bool operator<=(const NodeRef& lhs, const NodeRef& rhs) noexcept { return ! (rhs < lhs); } - inline bool operator>=(const NodeRef& lhs, const NodeRef& rhs) { + inline bool operator>=(const NodeRef& lhs, const NodeRef& rhs) noexcept { return ! (lhs < rhs); } @@ -122,7 +143,7 @@ namespace osmium { */ struct location_equal { - bool operator()(const NodeRef& lhs, const NodeRef& rhs) const { + bool operator()(const NodeRef& lhs, const NodeRef& rhs) const noexcept { return lhs.location() == rhs.location(); } @@ -137,7 +158,7 @@ namespace osmium { */ struct location_less { - bool operator()(const NodeRef& lhs, const NodeRef& rhs) const { + bool operator()(const NodeRef& lhs, const NodeRef& rhs) const noexcept { return lhs.location() < rhs.location(); } diff --git a/ThirdParty/osmium/osm/node_ref_list.hpp b/ThirdParty/osmium/osm/node_ref_list.hpp index 5ece86b06..321c952f4 100644 --- a/ThirdParty/osmium/osm/node_ref_list.hpp +++ b/ThirdParty/osmium/osm/node_ref_list.hpp @@ -1,135 +1,135 @@ -#ifndef OSMIUM_OSM_NODE_REF_LIST_HPP -#define OSMIUM_OSM_NODE_REF_LIST_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 -#include -#include - -#include -#include -#include - -namespace osmium { - - /** - * A vector of NodeRef objects. Usually this is not instatiated directly, - * but one of its subclasses are used. - */ - template - class NodeRefList : public osmium::memory::Item { - - public: - - static constexpr osmium::item_type itemtype = TItemType; - - NodeRefList(): - osmium::memory::Item(sizeof(NodeRefList), TItemType) { - } - - bool empty() const { - return sizeof(NodeRefList) == byte_size(); - } - - size_t size() const noexcept { - assert((osmium::memory::Item::byte_size() - sizeof(NodeRefList)) % sizeof(NodeRef) == 0); - return (osmium::memory::Item::byte_size() - sizeof(NodeRefList)) / sizeof(NodeRef); - } - - const NodeRef& operator[](size_t n) const { - const NodeRef* node_ref = &*(this->cbegin()); - return node_ref[n]; - } - - const NodeRef& front() const { - return operator[](0); - } - - const NodeRef& back() const { - return operator[](size()-1); - } - - bool is_closed() const { - return front().ref() == back().ref(); - } - - bool ends_have_same_id() const { - return front().ref() == back().ref(); - } - - bool ends_have_same_location() const { - return front().location() == back().location(); - } - - typedef NodeRef* iterator; - typedef const NodeRef* const_iterator; - typedef std::reverse_iterator const_reverse_iterator; - - iterator begin() { - return iterator(data() + sizeof(NodeRefList)); - } - - iterator end() { - return iterator(data() + byte_size()); - } - - const_iterator cbegin() const { - return const_iterator(data() + sizeof(NodeRefList)); - } - - const_iterator cend() const { - return const_iterator(data() + byte_size()); - } - - const_iterator begin() const { - return cbegin(); - } - - const_iterator end() const { - return cend(); - } - - const_reverse_iterator crbegin() const { - return const_reverse_iterator(this->cend()); - } - - const_reverse_iterator crend() const { - return const_reverse_iterator(this->cbegin()); - } - - }; // class NodeRefList - -} // namespace osmium - -#endif // OSMIUM_OSM_NODE_REF_LIST_HPP +#ifndef OSMIUM_OSM_NODE_REF_LIST_HPP +#define OSMIUM_OSM_NODE_REF_LIST_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include + +#include +#include +#include + +namespace osmium { + + /** + * A vector of NodeRef objects. Usually this is not instatiated directly, + * but one of its subclasses are used. + */ + template + class NodeRefList : public osmium::memory::Item { + + public: + + static constexpr osmium::item_type itemtype = TItemType; + + NodeRefList() noexcept : + osmium::memory::Item(sizeof(NodeRefList), TItemType) { + } + + bool empty() const noexcept { + return sizeof(NodeRefList) == byte_size(); + } + + size_t size() const noexcept { + assert((osmium::memory::Item::byte_size() - sizeof(NodeRefList)) % sizeof(NodeRef) == 0); + return (osmium::memory::Item::byte_size() - sizeof(NodeRefList)) / sizeof(NodeRef); + } + + const NodeRef& operator[](size_t n) const { + const NodeRef* node_ref = &*(cbegin()); + return node_ref[n]; + } + + const NodeRef& front() const { + return operator[](0); + } + + const NodeRef& back() const { + return operator[](size()-1); + } + + bool is_closed() const { + return front().ref() == back().ref(); + } + + bool ends_have_same_id() const { + return front().ref() == back().ref(); + } + + bool ends_have_same_location() const { + return front().location() == back().location(); + } + + typedef NodeRef* iterator; + typedef const NodeRef* const_iterator; + typedef std::reverse_iterator const_reverse_iterator; + + iterator begin() { + return iterator(data() + sizeof(NodeRefList)); + } + + iterator end() { + return iterator(data() + byte_size()); + } + + const_iterator cbegin() const { + return const_iterator(data() + sizeof(NodeRefList)); + } + + const_iterator cend() const { + return const_iterator(data() + byte_size()); + } + + const_iterator begin() const { + return cbegin(); + } + + const_iterator end() const { + return cend(); + } + + const_reverse_iterator crbegin() const { + return const_reverse_iterator(cend()); + } + + const_reverse_iterator crend() const { + return const_reverse_iterator(cbegin()); + } + + }; // class NodeRefList + +} // namespace osmium + +#endif // OSMIUM_OSM_NODE_REF_LIST_HPP diff --git a/ThirdParty/osmium/osm/object.hpp b/ThirdParty/osmium/osm/object.hpp index 1ef379892..9c4d60341 100644 --- a/ThirdParty/osmium/osm/object.hpp +++ b/ThirdParty/osmium/osm/object.hpp @@ -41,6 +41,7 @@ DEALINGS IN THE SOFTWARE. #include #include +#include #include #include #include @@ -62,19 +63,19 @@ namespace osmium { user_id_type m_uid; changeset_id_type m_changeset; - size_t sizeof_object() const { + size_t sizeof_object() const noexcept { return sizeof(OSMObject) + (type() == item_type::node ? sizeof(osmium::Location) : 0) + sizeof(string_size_type); } - unsigned char* user_position() { + unsigned char* user_position() noexcept { return data() + sizeof_object() - sizeof(string_size_type); } - const unsigned char* user_position() const { + const unsigned char* user_position() const noexcept { return data() + sizeof_object() - sizeof(string_size_type); } - string_size_type user_size() const { + string_size_type user_size() const noexcept { return *reinterpret_cast(user_position()); } @@ -98,52 +99,28 @@ namespace osmium { m_changeset(0) { } - void user_size(string_size_type size) { + void set_user_size(string_size_type size) { *reinterpret_cast(user_position()) = size; } - template - T& subitem_of_type() { - for (iterator it = begin(); it != end(); ++it) { - if (it->type() == T::itemtype) { - return reinterpret_cast(*it); - } - } - - static T subitem; - return subitem; - } - - template - const T& subitem_of_type() const { - for (const_iterator it = cbegin(); it != cend(); ++it) { - if (it->type() == T::itemtype) { - return reinterpret_cast(*it); - } - } - - static const T subitem; - return subitem; - } - public: /// Get ID of this object. - object_id_type id() const { + object_id_type id() const noexcept { return m_id; } /// Get absolute value of the ID of this object. - unsigned_object_id_type positive_id() const { + unsigned_object_id_type positive_id() const noexcept { return static_cast(std::abs(m_id)); } /** * Set ID of this object. * - * @return Reference to object to make calls chainable. + * @returns Reference to object to make calls chainable. */ - OSMObject& id(object_id_type id) { + OSMObject& set_id(object_id_type id) noexcept { m_id = id; return *this; } @@ -151,28 +128,28 @@ namespace osmium { /** * Set ID of this object. * - * @return Reference to object to make calls chainable. + * @returns Reference to object to make calls chainable. */ - OSMObject& id(const char* id) { - return this->id(osmium::string_to_object_id(id)); + OSMObject& set_id(const char* id) { + return set_id(osmium::string_to_object_id(id)); } /// Is this object marked as deleted? - bool deleted() const { + bool deleted() const noexcept { return m_deleted; } /// Is this object marked visible (ie not deleted)? - bool visible() const { + bool visible() const noexcept { return !deleted(); } /** * Mark this object as deleted (or not). * - * @return Reference to object to make calls chainable. + * @returns Reference to object to make calls chainable. */ - OSMObject& deleted(bool deleted) { + OSMObject& set_deleted(bool deleted) noexcept { m_deleted = deleted; return *this; } @@ -180,9 +157,9 @@ namespace osmium { /** * Mark this object as visible (ie not deleted) (or not). * - * @return Reference to object to make calls chainable. + * @returns Reference to object to make calls chainable. */ - OSMObject& visible(bool visible) { + OSMObject& set_visible(bool visible) noexcept { m_deleted = !visible; return *this; } @@ -191,13 +168,13 @@ namespace osmium { * Mark this object as visible (ie not deleted) or deleted. * * @param visible Either "true" or "false" - * @return Reference to object to make calls chainable. + * @returns Reference to object to make calls chainable. */ - OSMObject& visible(const char* visible) { + OSMObject& set_visible(const char* visible) { if (!strcmp("true", visible)) { - this->visible(true); + set_visible(true); } else if (!strcmp("false", visible)) { - this->visible(false); + set_visible(false); } else { throw std::invalid_argument("Unknown value for visible attribute (allowed is 'true' or 'false')"); } @@ -205,16 +182,16 @@ namespace osmium { } /// Get version of this object. - object_version_type version() const { + object_version_type version() const noexcept { return m_version; } /** * Set object version. * - * @return Reference to object to make calls chainable. + * @returns Reference to object to make calls chainable. */ - OSMObject& version(object_version_type version) { + OSMObject& set_version(object_version_type version) noexcept { m_version = version; return *this; } @@ -222,23 +199,23 @@ namespace osmium { /** * Set object version. * - * @return Reference to object to make calls chainable. + * @returns Reference to object to make calls chainable. */ - OSMObject& version(const char* version) { - return this->version(string_to_object_version(version)); + OSMObject& set_version(const char* version) { + return set_version(string_to_object_version(version)); } /// Get changeset id of this object. - changeset_id_type changeset() const { + changeset_id_type changeset() const noexcept { return m_changeset; } /** * Set changeset id of this object. * - * @return Reference to object to make calls chainable. + * @returns Reference to object to make calls chainable. */ - OSMObject& changeset(changeset_id_type changeset) { + OSMObject& set_changeset(changeset_id_type changeset) noexcept { m_changeset = changeset; return *this; } @@ -246,23 +223,23 @@ namespace osmium { /** * Set changeset id of this object. * - * @return Reference to object to make calls chainable. + * @returns Reference to object to make calls chainable. */ - OSMObject& changeset(const char* changeset) { - return this->changeset(string_to_changeset_id(changeset)); + OSMObject& set_changeset(const char* changeset) { + return set_changeset(string_to_changeset_id(changeset)); } /// Get user id of this object. - user_id_type uid() const { + user_id_type uid() const noexcept { return m_uid; } /** * Set user id of this object. * - * @return Reference to object to make calls chainable. + * @returns Reference to object to make calls chainable. */ - OSMObject& uid(user_id_type uid) { + OSMObject& set_uid(user_id_type uid) noexcept { m_uid = uid; return *this; } @@ -271,9 +248,9 @@ namespace osmium { * Set user id of this object. * Sets uid to 0 (anonymous) if the given uid is smaller than 0. * - * @return Reference to object to make calls chainable. + * @returns Reference to object to make calls chainable. */ - OSMObject& uid_from_signed(signed_user_id_type uid) { + OSMObject& set_uid_from_signed(signed_user_id_type uid) noexcept { m_uid = uid < 0 ? 0 : static_cast(uid); return *this; } @@ -281,19 +258,19 @@ namespace osmium { /** * Set user id of this object. * - * @return Reference to object to make calls chainable. + * @returns Reference to object to make calls chainable. */ - OSMObject& uid(const char* uid) { - return this->uid_from_signed(string_to_user_id(uid)); + OSMObject& set_uid(const char* uid) { + return set_uid_from_signed(string_to_user_id(uid)); } /// Is this user anonymous? - bool user_is_anonymous() const { + bool user_is_anonymous() const noexcept { return m_uid == 0; } /// Get timestamp when this object last changed. - osmium::Timestamp timestamp() const { + osmium::Timestamp timestamp() const noexcept { return m_timestamp; } @@ -301,26 +278,21 @@ namespace osmium { * Set the timestamp when this object last changed. * * @param timestamp Timestamp - * @return Reference to object to make calls chainable. + * @returns Reference to object to make calls chainable. */ - OSMObject& timestamp(const osmium::Timestamp timestamp) { + OSMObject& set_timestamp(const osmium::Timestamp timestamp) noexcept { m_timestamp = timestamp; return *this; } /// Get user name for this object. - const char* user() const { + const char* user() const noexcept { return reinterpret_cast(data() + sizeof_object()); } - /// Get the list of tags for this object. - TagList& tags() { - return subitem_of_type(); - } - /// Get the list of tags for this object. const TagList& tags() const { - return subitem_of_type(); + return osmium::detail::subitem_of_type(cbegin(), cend()); } /** @@ -341,17 +313,17 @@ namespace osmium { */ void set_attribute(const char* attr, const char* value) { if (!strcmp(attr, "id")) { - id(value); + set_id(value); } else if (!strcmp(attr, "version")) { - version(value); + set_version(value); } else if (!strcmp(attr, "changeset")) { - changeset(value); + set_changeset(value); } else if (!strcmp(attr, "timestamp")) { - timestamp(osmium::Timestamp(value)); + set_timestamp(osmium::Timestamp(value)); } else if (!strcmp(attr, "uid")) { - uid(value); + set_uid(value); } else if (!strcmp(attr, "visible")) { - visible(value); + set_visible(value); } } @@ -363,7 +335,7 @@ namespace osmium { } iterator end() { - return iterator(data() + padded_size()); + return iterator(next()); } const_iterator cbegin() const { @@ -371,7 +343,7 @@ namespace osmium { } const_iterator cend() const { - return const_iterator(data() + padded_size()); + return const_iterator(next()); } const_iterator begin() const { @@ -382,6 +354,42 @@ namespace osmium { return cend(); } + template + using t_iterator = osmium::memory::ItemIterator; + + template + using t_const_iterator = osmium::memory::ItemIterator; + + template + t_iterator begin() { + return t_iterator(subitems_position(), next()); + } + + template + t_iterator end() { + return t_iterator(next(), next()); + } + + template + t_const_iterator cbegin() const { + return t_const_iterator(subitems_position(), next()); + } + + template + t_const_iterator cend() const { + return t_const_iterator(next(), next()); + } + + template + t_const_iterator begin() const { + return cbegin(); + } + + template + t_const_iterator end() const { + return cend(); + } + }; // class OSMObject static_assert(sizeof(OSMObject) % osmium::memory::align_bytes == 0, "Class osmium::OSMObject has wrong size to be aligned properly!"); @@ -389,13 +397,13 @@ namespace osmium { /** * OSMObjects are equal if their type, id, and version are equal. */ - inline bool operator==(const OSMObject& lhs, const OSMObject& rhs) { + inline bool operator==(const OSMObject& lhs, const OSMObject& rhs) noexcept { return lhs.type() == rhs.type() && lhs.id() == rhs.id() && lhs.version() == rhs.version(); } - inline bool operator!=(const OSMObject& lhs, const OSMObject& rhs) { + inline bool operator!=(const OSMObject& lhs, const OSMObject& rhs) noexcept { return ! (lhs == rhs); } @@ -404,7 +412,7 @@ namespace osmium { * Note that we use the absolute value of the id for a * better ordering of objects with negative id. */ - inline bool operator<(const OSMObject& lhs, const OSMObject& rhs) { + inline bool operator<(const OSMObject& lhs, const OSMObject& rhs) noexcept { if (lhs.type() != rhs.type()) { return lhs.type() < rhs.type(); } @@ -412,15 +420,15 @@ namespace osmium { lhs.positive_id() < rhs.positive_id(); } - inline bool operator>(const OSMObject& lhs, const OSMObject& rhs) { + inline bool operator>(const OSMObject& lhs, const OSMObject& rhs) noexcept { return rhs < lhs; } - inline bool operator<=(const OSMObject& lhs, const OSMObject& rhs) { + inline bool operator<=(const OSMObject& lhs, const OSMObject& rhs) noexcept { return ! (rhs < lhs); } - inline bool operator>=(const OSMObject& lhs, const OSMObject& rhs) { + inline bool operator>=(const OSMObject& lhs, const OSMObject& rhs) noexcept { return ! (lhs < rhs); } diff --git a/ThirdParty/osmium/osm/object_comparisons.hpp b/ThirdParty/osmium/osm/object_comparisons.hpp index 5c2bf6cc6..db11b0d4c 100644 --- a/ThirdParty/osmium/osm/object_comparisons.hpp +++ b/ThirdParty/osmium/osm/object_comparisons.hpp @@ -1,110 +1,110 @@ -#ifndef OSMIUM_OSM_OBJECT_COMPARISONS_HPP -#define OSMIUM_OSM_OBJECT_COMPARISONS_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 - -namespace osmium { - - /** - * Function object class for comparing OSM objects for equality by type, id, and version. - */ - struct object_equal_type_id_version { - - bool operator()(const osmium::OSMObject& lhs, const osmium::OSMObject& rhs) const { - return lhs == rhs; - } - - bool operator()(const osmium::OSMObject* lhs, const osmium::OSMObject* rhs) const { - return *lhs == *rhs; - } - - }; // struct object_equal_type_id_version - - /** - * Function object class for comparing OSM objects for equality by type and id, - * ignoring the version. - */ - struct object_equal_type_id { - - bool operator()(const osmium::OSMObject& lhs, const osmium::OSMObject& rhs) const { - return lhs.type() == rhs.type() && - lhs.id() == rhs.id(); - } - - bool operator()(const osmium::OSMObject* lhs, const osmium::OSMObject* rhs) const { - return operator()(*lhs, *rhs); - } - - }; // struct object_equal_type_id - - /** - * Function object class for ordering OSM objects by type, id, and version. - */ - struct object_order_type_id_version { - - bool operator()(const osmium::OSMObject& lhs, const osmium::OSMObject& rhs) const { - return lhs < rhs; - } - - bool operator()(const osmium::OSMObject* lhs, const osmium::OSMObject* rhs) const { - return *lhs < *rhs; - } - - }; // struct object_order_type_id_version - - /** - * Function object class for ordering OSM objects by type, id, and reverse version, - * ie objects are ordered by type and id, but later versions of an object are - * ordered before earlier versions of the same object. - */ - struct object_order_type_id_reverse_version { - - bool operator()(const osmium::OSMObject& lhs, const osmium::OSMObject& rhs) const { - if (lhs.type() != rhs.type()) { - return lhs.type() < rhs.type(); - } - return (lhs.id() == rhs.id() && lhs.version() > rhs.version()) || - lhs.positive_id() < rhs.positive_id(); - } - - bool operator()(const osmium::OSMObject* lhs, const osmium::OSMObject* rhs) const { - return operator()(*lhs, *rhs); - } - - }; // struct object_order_type_id_reverse_version - -} // namespace osmium - -#endif // OSMIUM_OSM_OBJECT_COMPARISONS_HPP +#ifndef OSMIUM_OSM_OBJECT_COMPARISONS_HPP +#define OSMIUM_OSM_OBJECT_COMPARISONS_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 + +namespace osmium { + + /** + * Function object class for comparing OSM objects for equality by type, id, and version. + */ + struct object_equal_type_id_version { + + bool operator()(const osmium::OSMObject& lhs, const osmium::OSMObject& rhs) const noexcept { + return lhs == rhs; + } + + bool operator()(const osmium::OSMObject* lhs, const osmium::OSMObject* rhs) const noexcept { + return *lhs == *rhs; + } + + }; // struct object_equal_type_id_version + + /** + * Function object class for comparing OSM objects for equality by type and id, + * ignoring the version. + */ + struct object_equal_type_id { + + bool operator()(const osmium::OSMObject& lhs, const osmium::OSMObject& rhs) const noexcept { + return lhs.type() == rhs.type() && + lhs.id() == rhs.id(); + } + + bool operator()(const osmium::OSMObject* lhs, const osmium::OSMObject* rhs) const noexcept { + return operator()(*lhs, *rhs); + } + + }; // struct object_equal_type_id + + /** + * Function object class for ordering OSM objects by type, id, and version. + */ + struct object_order_type_id_version { + + bool operator()(const osmium::OSMObject& lhs, const osmium::OSMObject& rhs) const noexcept { + return lhs < rhs; + } + + bool operator()(const osmium::OSMObject* lhs, const osmium::OSMObject* rhs) const noexcept { + return *lhs < *rhs; + } + + }; // struct object_order_type_id_version + + /** + * Function object class for ordering OSM objects by type, id, and reverse version, + * ie objects are ordered by type and id, but later versions of an object are + * ordered before earlier versions of the same object. + */ + struct object_order_type_id_reverse_version { + + bool operator()(const osmium::OSMObject& lhs, const osmium::OSMObject& rhs) const noexcept { + if (lhs.type() != rhs.type()) { + return lhs.type() < rhs.type(); + } + return (lhs.id() == rhs.id() && lhs.version() > rhs.version()) || + lhs.positive_id() < rhs.positive_id(); + } + + bool operator()(const osmium::OSMObject* lhs, const osmium::OSMObject* rhs) const noexcept { + return operator()(*lhs, *rhs); + } + + }; // struct object_order_type_id_reverse_version + +} // namespace osmium + +#endif // OSMIUM_OSM_OBJECT_COMPARISONS_HPP diff --git a/ThirdParty/osmium/osm/relation.hpp b/ThirdParty/osmium/osm/relation.hpp index 7974e7aad..f5d040100 100644 --- a/ThirdParty/osmium/osm/relation.hpp +++ b/ThirdParty/osmium/osm/relation.hpp @@ -93,7 +93,7 @@ namespace osmium { } } - void set_role_size(string_size_type size) { + void set_role_size(string_size_type size) noexcept { m_role_size = size; } @@ -101,34 +101,34 @@ namespace osmium { static constexpr item_type collection_type = item_type::relation_member_list; - RelationMember(const object_id_type ref=0, const item_type type=item_type(), const bool full=false) : + RelationMember(const object_id_type ref=0, const item_type type=item_type(), const bool full=false) noexcept : m_ref(ref), m_type(type), m_flags(full ? 1 : 0) { } - object_id_type ref() const { + object_id_type ref() const noexcept { return m_ref; } - RelationMember& ref(object_id_type ref) { + RelationMember& ref(object_id_type ref) noexcept { m_ref = ref; return *this; } - unsigned_object_id_type positive_ref() const { + unsigned_object_id_type positive_ref() const noexcept { return static_cast(std::abs(m_ref)); } - item_type type() const { + item_type type() const noexcept { return m_type; } - bool full_member() const { + bool full_member() const noexcept { return m_flags == 1; } - const char* role() const { + const char* role() const noexcept { return reinterpret_cast(data() + sizeof(RelationMember)); } @@ -164,7 +164,7 @@ namespace osmium { friend class osmium::builder::ObjectBuilder; - Relation() : + Relation() noexcept : OSMObject(sizeof(Relation), osmium::item_type::relation) { } @@ -173,11 +173,11 @@ namespace osmium { static constexpr osmium::item_type itemtype = osmium::item_type::relation; RelationMemberList& members() { - return subitem_of_type(); + return osmium::detail::subitem_of_type(begin(), end()); } const RelationMemberList& members() const { - return subitem_of_type(); + return osmium::detail::subitem_of_type(cbegin(), cend()); } }; // class Relation diff --git a/ThirdParty/osmium/osm/segment.hpp b/ThirdParty/osmium/osm/segment.hpp index b08679165..205036ec6 100644 --- a/ThirdParty/osmium/osm/segment.hpp +++ b/ThirdParty/osmium/osm/segment.hpp @@ -51,7 +51,7 @@ namespace osmium { public: - explicit constexpr Segment(const osmium::Location& location1, const osmium::Location& location2) : + explicit constexpr Segment(const osmium::Location& location1, const osmium::Location& location2) noexcept : m_first(location1), m_second(location2) { } @@ -65,12 +65,12 @@ namespace osmium { ~Segment() = default; /// Return first Location of Segment. - OSMIUM_CONSTEXPR osmium::Location first() const { + OSMIUM_CONSTEXPR osmium::Location first() const noexcept { return m_first; } /// Return second Location of Segment. - OSMIUM_CONSTEXPR osmium::Location second() const { + OSMIUM_CONSTEXPR osmium::Location second() const noexcept { return m_second; } @@ -84,11 +84,11 @@ namespace osmium { }; // class Segment /// Segments are equal if both their locations are equal - inline OSMIUM_CONSTEXPR bool operator==(const Segment& lhs, const Segment& rhs) { + inline OSMIUM_CONSTEXPR bool operator==(const Segment& lhs, const Segment& rhs) noexcept { return lhs.first() == rhs.first() && lhs.second() == rhs.second(); } - inline OSMIUM_CONSTEXPR bool operator!=(const Segment& lhs, const Segment& rhs) { + inline OSMIUM_CONSTEXPR bool operator!=(const Segment& lhs, const Segment& rhs) noexcept { return ! (lhs == rhs); } diff --git a/ThirdParty/osmium/osm/tag.hpp b/ThirdParty/osmium/osm/tag.hpp index df994a134..fe80de34f 100644 --- a/ThirdParty/osmium/osm/tag.hpp +++ b/ThirdParty/osmium/osm/tag.hpp @@ -76,7 +76,7 @@ namespace osmium { static constexpr item_type collection_type = item_type::tag_list; - const char* key() const { + const char* key() const noexcept { return reinterpret_cast(data()); } diff --git a/ThirdParty/osmium/osm/timestamp.hpp b/ThirdParty/osmium/osm/timestamp.hpp index 7e25f83e8..662b61f5b 100644 --- a/ThirdParty/osmium/osm/timestamp.hpp +++ b/ThirdParty/osmium/osm/timestamp.hpp @@ -67,13 +67,13 @@ namespace osmium { public: - constexpr Timestamp() : + constexpr Timestamp() noexcept : m_timestamp(0) { } // Not "explicit" so that conversions from time_t work // like in node.timestamp(123); - constexpr Timestamp(time_t timestamp) : + constexpr Timestamp(time_t timestamp) noexcept : m_timestamp(static_cast(timestamp)) { } @@ -82,7 +82,7 @@ namespace osmium { * Throws std::invalid_argument, if the timestamp can not be parsed. */ explicit Timestamp(const char* timestamp) { -#ifndef WIN32 +#ifndef _WIN32 struct tm tm { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; @@ -105,14 +105,24 @@ namespace osmium { #endif } - constexpr time_t seconds_since_epoch() const { + constexpr time_t seconds_since_epoch() const noexcept { return static_cast(m_timestamp); } - constexpr operator time_t() const { + constexpr operator time_t() const noexcept { return static_cast(m_timestamp); } + template + void operator+=(T time_difference) noexcept { + m_timestamp += time_difference; + } + + template + void operator-=(T time_difference) noexcept { + m_timestamp -= time_difference; + } + /** * Return UTC Unix time as string in ISO date/time format. */ @@ -140,11 +150,11 @@ namespace osmium { }; // class Timestamp - inline OSMIUM_CONSTEXPR Timestamp start_of_time() { + inline OSMIUM_CONSTEXPR Timestamp start_of_time() noexcept { return Timestamp(1); } - inline OSMIUM_CONSTEXPR Timestamp end_of_time() { + inline OSMIUM_CONSTEXPR Timestamp end_of_time() noexcept { return Timestamp(std::numeric_limits::max()); } diff --git a/ThirdParty/osmium/osm/undirected_segment.hpp b/ThirdParty/osmium/osm/undirected_segment.hpp index 8805162ec..487e7bf32 100644 --- a/ThirdParty/osmium/osm/undirected_segment.hpp +++ b/ThirdParty/osmium/osm/undirected_segment.hpp @@ -71,19 +71,19 @@ namespace osmium { * 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 UndirectedSegment& lhs, const UndirectedSegment& rhs) { + inline bool operator<(const UndirectedSegment& lhs, const UndirectedSegment& rhs) noexcept { return (lhs.first() == rhs.first() && lhs.second() < rhs.second()) || lhs.first() < rhs.first(); } - inline bool operator>(const UndirectedSegment& lhs, const UndirectedSegment& rhs) { + inline bool operator>(const UndirectedSegment& lhs, const UndirectedSegment& rhs) noexcept { return rhs < lhs; } - inline bool operator<=(const UndirectedSegment& lhs, const UndirectedSegment& rhs) { + inline bool operator<=(const UndirectedSegment& lhs, const UndirectedSegment& rhs) noexcept { return ! (rhs < lhs); } - inline bool operator>=(const UndirectedSegment& lhs, const UndirectedSegment& rhs) { + inline bool operator>=(const UndirectedSegment& lhs, const UndirectedSegment& rhs) noexcept { return ! (lhs < rhs); } diff --git a/ThirdParty/osmium/osm/way.hpp b/ThirdParty/osmium/osm/way.hpp index c55698c21..a30cf911f 100644 --- a/ThirdParty/osmium/osm/way.hpp +++ b/ThirdParty/osmium/osm/way.hpp @@ -1,115 +1,115 @@ -#ifndef OSMIUM_OSM_WAY_HPP -#define OSMIUM_OSM_WAY_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 -#include -#include -#include -#include -#include - -namespace osmium { - - namespace builder { - template class ObjectBuilder; - } - - /** - * List of node references (id and location) in a way. - */ - class WayNodeList : public NodeRefList { - - public: - - WayNodeList(): - NodeRefList() { - } - - }; // class WayNodeList - - static_assert(sizeof(WayNodeList) % osmium::memory::align_bytes == 0, "Class osmium::WayNodeList has wrong size to be aligned properly!"); - - class Way : public OSMObject { - - friend class osmium::builder::ObjectBuilder; - - Way() : - OSMObject(sizeof(Way), osmium::item_type::way) { - } - - public: - - WayNodeList& nodes() { - return subitem_of_type(); - } - - const WayNodeList& nodes() const { - return subitem_of_type(); - } - - /** - * Update all nodes in a way with the ID of the given NodeRef with the - * location of the given NodeRef. - */ - void update_node_location(const NodeRef& new_node_ref) { - for (auto& node_ref : nodes()) { - if (node_ref.ref() == new_node_ref.ref()) { - node_ref.location(new_node_ref.location()); - } - } - } - - /** - * Do the nodes in this way form a closed ring? - */ - bool is_closed() const { - return nodes().is_closed(); - } - - bool ends_have_same_id() const { - return nodes().ends_have_same_id(); - } - - bool ends_have_same_location() const { - return nodes().ends_have_same_location(); - } - - }; // class Way - - static_assert(sizeof(Way) % osmium::memory::align_bytes == 0, "Class osmium::Way has wrong size to be aligned properly!"); - -} // namespace osmium - -#endif // OSMIUM_OSM_WAY_HPP +#ifndef OSMIUM_OSM_WAY_HPP +#define OSMIUM_OSM_WAY_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include +#include +#include + +namespace osmium { + + namespace builder { + template class ObjectBuilder; + } + + /** + * List of node references (id and location) in a way. + */ + class WayNodeList : public NodeRefList { + + public: + + WayNodeList(): + NodeRefList() { + } + + }; // class WayNodeList + + static_assert(sizeof(WayNodeList) % osmium::memory::align_bytes == 0, "Class osmium::WayNodeList has wrong size to be aligned properly!"); + + class Way : public OSMObject { + + friend class osmium::builder::ObjectBuilder; + + Way() noexcept : + OSMObject(sizeof(Way), osmium::item_type::way) { + } + + public: + + WayNodeList& nodes() { + return osmium::detail::subitem_of_type(begin(), end()); + } + + const WayNodeList& nodes() const { + return osmium::detail::subitem_of_type(cbegin(), cend()); + } + + /** + * Update all nodes in a way with the ID of the given NodeRef with the + * location of the given NodeRef. + */ + void update_node_location(const NodeRef& new_node_ref) { + for (auto& node_ref : nodes()) { + if (node_ref.ref() == new_node_ref.ref()) { + node_ref.set_location(new_node_ref.location()); + } + } + } + + /** + * Do the nodes in this way form a closed ring? + */ + bool is_closed() const { + return nodes().is_closed(); + } + + bool ends_have_same_id() const { + return nodes().ends_have_same_id(); + } + + bool ends_have_same_location() const { + return nodes().ends_have_same_location(); + } + + }; // class Way + + static_assert(sizeof(Way) % osmium::memory::align_bytes == 0, "Class osmium::Way has wrong size to be aligned properly!"); + +} // namespace osmium + +#endif // OSMIUM_OSM_WAY_HPP diff --git a/ThirdParty/osmium/relations/collector.hpp b/ThirdParty/osmium/relations/collector.hpp index cc7a5964e..8d3bb9150 100644 --- a/ThirdParty/osmium/relations/collector.hpp +++ b/ThirdParty/osmium/relations/collector.hpp @@ -1,535 +1,542 @@ -#ifndef OSMIUM_RELATIONS_COLLECTOR_HPP -#define OSMIUM_RELATIONS_COLLECTOR_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include // IWYU pragma: keep -#include -#include -#include -#include - -#include -#include - -namespace osmium { - - class Node; - class Way; - - /** - * @brief Code related to the assembly of OSM relations - */ - namespace relations { - - /** - * The Collector class collects members of a relation. This is a generic - * base class that can be used to assemble all kinds of relations. It has numerous - * hooks you can implement in derived classes to customize its behaviour. - * - * The collector provides two handlers (HandlerPass1 and HandlerPass2) for a first - * and second pass through an input file, respectively. In the first pass all - * relations we are interested in are stored in RelationMeta objects in the - * m_relations vector. All members we are interested in are stored in MemberMeta - * objects in the m_member_meta vectors. - * The MemberMeta objects also store the information where the relations containing - * those members are to be found. - * - * Later the m_member_meta vectors are sorted according to the - * member ids so that a binary search (with std::equal_range) can be used in the second - * pass to find the parent relations for each node, way, or relation coming along. - * The member objects are stored together with their relation and once a relation - * is complete the complete_relation() method is called which you must overwrite in - * a derived class of Collector. - * - * @tparam TCollector Derived class of this class. - * - * @tparam TNodes Are we interested in member nodes? - * - * @tparam TWays Are we interested in member ways? - * - * @tparam TRelations Are we interested in member relations? - */ - template - class Collector { - - /** - * This is the handler class for the first pass of the Collector. - */ - class HandlerPass1 : public osmium::handler::Handler { - - TCollector& m_collector; - - public: - - HandlerPass1(TCollector& collector) : - m_collector(collector) { - } - - void relation(const osmium::Relation& relation) { - if (m_collector.keep_relation(relation)) { - m_collector.add_relation(relation); - } - } - - }; // class HandlerPass1 - - /** - * This is the handler class for the second pass of the Collector. - */ - class HandlerPass2 : public osmium::handler::Handler { - - TCollector& m_collector; - - /** - * This variable is initialized with the number of different - * kinds of OSM objects we are interested in. If we only need - * way members (for instance for the multipolygon collector) - * it is intialized with 1 for instance. If node and way - * members are needed, it is initialized with 2. - * - * In the after_* methods of this handler, it is decremented - * and once it reaches 0, we know we have all members available - * that we are ever going to get. - */ - int m_want_types; - - /** - * Find this object in the member vectors and add it to all - * relations that need it. - * - * @returns true if the member was added to at least one - * relation and false otherwise - */ - bool find_and_add_object(const osmium::OSMObject& object) { - auto& mmv = m_collector.member_meta(object.type()); - auto range = std::equal_range(mmv.begin(), mmv.end(), MemberMeta(object.id())); - - if (range.first == range.second) { - // nothing found - return false; - } - - { - const size_t member_offset = m_collector.members_buffer().committed(); - m_collector.members_buffer().add_item(object); - m_collector.members_buffer().commit(); - - for (auto it = range.first; it != range.second; ++it) { - it->buffer_offset(member_offset); - } - } - - for (auto it = range.first; it != range.second; ++it) { - MemberMeta& member_meta = *it; - assert(member_meta.member_id() == object.id()); - assert(member_meta.relation_pos() < m_collector.m_relations.size()); - RelationMeta& relation_meta = m_collector.m_relations[member_meta.relation_pos()]; -// std::cerr << " => " << member_meta.member_pos() << " < " << m_collector.get_relation(relation_meta).members().size() << " (id=" << m_collector.get_relation(relation_meta).id() << ")\n"; - assert(member_meta.member_pos() < m_collector.get_relation(relation_meta).members().size()); -// std::cerr << " add way " << member_meta.member_id() << " to rel " << m_collector.get_relation(relation_meta).id() << " at pos " << member_meta.member_pos() << "\n"; - relation_meta.got_one_member(); - if (relation_meta.has_all_members()) { - const size_t relation_offset = member_meta.relation_pos(); - m_collector.complete_relation(relation_meta); - m_collector.m_relations[relation_offset] = RelationMeta(); - m_collector.possibly_purge_removed_members(); - } - } - - return true; - } - - public: - - HandlerPass2(TCollector& collector) : - m_collector(collector), - m_want_types((TNodes?1:0) + (TWays?1:0) + (TRelations?1:0)) { - } - - void node(const osmium::Node& node) { - if (TNodes) { - if (! find_and_add_object(node)) { - m_collector.node_not_in_any_relation(node); - } - } - } - - void way(const osmium::Way& way) { - if (TWays) { - if (! find_and_add_object(way)) { - m_collector.way_not_in_any_relation(way); - } - } - } - - void relation(const osmium::Relation& relation) { - if (TRelations) { - if (! find_and_add_object(relation)) { - m_collector.relation_not_in_any_relation(relation); - } - } - } - - void flush() { - m_collector.flush(); - } - - }; // class HandlerPass2 - - HandlerPass2 m_handler_pass2; - - // All relations we are interested in will be kept in this buffer - osmium::memory::Buffer m_relations_buffer; - - // All members we are interested in will be kept in this buffer - osmium::memory::Buffer m_members_buffer; - - /// Vector with all relations we are interested in - std::vector m_relations; - - /** - * One vector each for nodes, ways, and relations containing all - * mappings from member ids to their relations. - */ - std::vector m_member_meta[3]; - - int m_count_complete = 0; - - typedef std::function callback_func_type; - callback_func_type m_callback; - - static constexpr size_t initial_buffer_size = 1024 * 1024; - - public: - - /** - * Create an Collector. - */ - Collector() : - m_handler_pass2(*static_cast(this)), - m_relations_buffer(initial_buffer_size, osmium::memory::Buffer::auto_grow::yes), - m_members_buffer(initial_buffer_size, osmium::memory::Buffer::auto_grow::yes), - m_relations(), - m_member_meta() { - } - - protected: - - std::vector& member_meta(const item_type type) { - return m_member_meta[static_cast(type) - 1]; - } - - callback_func_type callback() { - return m_callback; - } - - const std::vector& relations() const { - return m_relations; - } - - /** - * This method is called from the first pass handler for every - * relation in the input, to check whether it should be kept. - * - * Overwrite this method in a child class to only add relations - * you are interested in, for instance depending on the type tag. - * Storing relations takes a lot of memory, so it makes sense to - * filter this as much as possible. - */ - bool keep_relation(const osmium::Relation& /*relation*/) const { - return true; - } - - /** - * This method is called for every member of every relation that - * should be kept. It should decide if the member is interesting or - * not and return true or false to signal that. Only interesting - * members are later added to the relation. - * - * Overwrite this method in a child class. In the MultiPolygonCollector - * this is for instance used to only keep members of type way and - * ignore all others. - */ - bool keep_member(const osmium::relations::RelationMeta& /*relation_meta*/, const osmium::RelationMember& /*member*/) const { - return true; - } - - /** - * This method is called for all nodes that are not a member of - * any relation. - * - * Overwrite this method in a child class if you are interested - * in this. - */ - void node_not_in_any_relation(const osmium::Node& /*node*/) { - } - - /** - * This method is called for all ways that are not a member of - * any relation. - * - * Overwrite this method in a child class if you are interested - * in this. - */ - void way_not_in_any_relation(const osmium::Way& /*way*/) { - } - - /** - * This method is called for all relations that are not a member of - * any relation. - * - * Overwrite this method in a child class if you are interested - * in this. - */ - void relation_not_in_any_relation(const osmium::Relation& /*relation*/) { - } - - /** - * This method is called from the 2nd pass handler when all objects - * of types we are interested in have been seen. - * - * Overwrite this method in a child class if you are interested - * in this. - * - * Note that even after this call members might be missing if they - * were not in the input file! The derived class has to handle this - * case. - */ - void flush() { - } - - /** - * This removes all relations that have already been assembled - * from the m_relations vector. - */ - void clean_assembled_relations() { - m_relations.erase( - std::remove_if(m_relations.begin(), m_relations.end(), has_all_members()), - m_relations.end() - ); - } - - const osmium::Relation& get_relation(size_t offset) const { - return m_relations_buffer.get(offset); - } - - /** - * Get the relation from a relation_meta. - */ - const osmium::Relation& get_relation(const RelationMeta& relation_meta) const { - return get_relation(relation_meta.relation_offset()); - } - - osmium::OSMObject& get_member(size_t offset) const { - return m_members_buffer.get(offset); - } - - /** - * Tell the Collector that you are interested in this relation - * and want it kept until all members have been assembled and - * it is handed back to you. - * - * The relation is copied and stored in a buffer inside the - * collector. - */ - void add_relation(const osmium::Relation& relation) { - const size_t offset = m_relations_buffer.committed(); - m_relations_buffer.add_item(relation); - - RelationMeta relation_meta(offset); - - int n=0; - for (auto& member : m_relations_buffer.get(offset).members()) { - if (static_cast(this)->keep_member(relation_meta, member)) { - member_meta(member.type()).emplace_back(member.ref(), m_relations.size(), n); - relation_meta.increment_need_members(); - } else { - member.ref(0); // set member id to zero to indicate we are not interested - } - ++n; - } - - assert(offset == m_relations_buffer.committed()); - if (relation_meta.has_all_members()) { - m_relations_buffer.rollback(); - } else { - m_relations_buffer.commit(); - m_relations.push_back(std::move(relation_meta)); -// std::cerr << "added relation id=" << relation.id() << "\n"; - } - } - - /** - * Sort the vectors with the member infos so that we can do binary - * search on them. - */ - void sort_member_meta() { -/* std::cerr << "relations: " << m_relations.size() << "\n"; - std::cerr << "node members: " << m_member_meta[0].size() << "\n"; - std::cerr << "way members: " << m_member_meta[1].size() << "\n"; - std::cerr << "relation members: " << m_member_meta[2].size() << "\n";*/ - std::sort(m_member_meta[0].begin(), m_member_meta[0].end()); - std::sort(m_member_meta[1].begin(), m_member_meta[1].end()); - std::sort(m_member_meta[2].begin(), m_member_meta[2].end()); - } - - public: - - uint64_t used_memory() const { - const uint64_t nmembers = m_member_meta[0].capacity() + m_member_meta[1].capacity() + m_member_meta[2].capacity(); - const uint64_t members = nmembers * sizeof(MemberMeta); - const uint64_t relations = m_relations.capacity() * sizeof(RelationMeta); - const uint64_t relations_buffer_capacity = m_relations_buffer.capacity(); - const uint64_t members_buffer_capacity = m_members_buffer.capacity(); - - std::cout << " nR = m_relations.capacity() ........... = " << std::setw(12) << m_relations.capacity() << "\n"; - std::cout << " nMN = m_member_meta[NODE].capacity() ... = " << std::setw(12) << m_member_meta[0].capacity() << "\n"; - std::cout << " nMW = m_member_meta[WAY].capacity() .... = " << std::setw(12) << m_member_meta[1].capacity() << "\n"; - std::cout << " nMR = m_member_meta[RELATION].capacity() = " << std::setw(12) << m_member_meta[2].capacity() << "\n"; - std::cout << " nM = m_member_meta[*].capacity() ...... = " << std::setw(12) << nmembers << "\n"; - - std::cout << " sRM = sizeof(RelationMeta) ............. = " << std::setw(12) << sizeof(RelationMeta) << "\n"; - std::cout << " sMM = sizeof(MemberMeta) ............... = " << std::setw(12) << sizeof(MemberMeta) << "\n\n"; - - std::cout << " nR * sRM ............................... = " << std::setw(12) << relations << "\n"; - std::cout << " nM * sMM ............................... = " << std::setw(12) << members << "\n"; - std::cout << " relations_buffer_capacity .............. = " << std::setw(12) << relations_buffer_capacity << "\n"; - std::cout << " members_buffer_capacity ................ = " << std::setw(12) << members_buffer_capacity << "\n"; - - const uint64_t total = relations + members + relations_buffer_capacity + members_buffer_capacity; - - std::cout << " total .................................. = " << std::setw(12) << total << "\n"; - std::cout << " =======================================================\n"; - - return relations_buffer_capacity + members_buffer_capacity + relations + members; - } - - /** - * Return reference to second pass handler. - */ - HandlerPass2& handler(const callback_func_type& callback = nullptr) { - m_callback = callback; - return m_handler_pass2; - } - - osmium::memory::Buffer& members_buffer() { - return m_members_buffer; - } - - size_t get_offset(osmium::item_type type, osmium::object_id_type id) { - const auto& mmv = member_meta(type); - const auto range = std::equal_range(mmv.cbegin(), mmv.cend(), MemberMeta(id)); - assert(range.first != range.second); - return range.first->buffer_offset(); - } - - template - void read_relations(TIter begin, TIter end) { - HandlerPass1 handler(*static_cast(this)); - osmium::apply(begin, end, handler); - sort_member_meta(); - } - - template - void read_relations(TSource& source) { - read_relations(std::begin(source), std::end(source)); - source.close(); - } - - void moving_in_buffer(size_t old_offset, size_t new_offset) { - const osmium::OSMObject& object = m_members_buffer.get(old_offset); - auto& mmv = member_meta(object.type()); - auto range = std::equal_range(mmv.begin(), mmv.end(), osmium::relations::MemberMeta(object.id())); - for (auto it = range.first; it != range.second; ++it) { - assert(it->buffer_offset() == old_offset); - it->buffer_offset(new_offset); - } - } - - /** - * Decide whether to purge removed members and then do it. - * - * Currently the purging is done every thousand calls. - * This could probably be improved upon. - */ - void possibly_purge_removed_members() { - ++m_count_complete; - if (m_count_complete > 10000) { // XXX - const size_t size_before = m_members_buffer.committed(); - m_members_buffer.purge_removed(this); - const size_t size_after = m_members_buffer.committed(); - double percent = size_before - size_after; - percent /= size_before; - percent *= 100; - std::cerr << "PURGE (size before=" << size_before << " after=" << size_after << " purged=" << (size_before - size_after) << " / " << static_cast(percent) << "%)\n"; - m_count_complete = 0; - } - } - - /** - * Get a vector with pointers to all Relations that could not - * be completed, because members were missing in the input - * data. - * - * Note that these pointers point into memory allocated and - * owned by the Collector object. - */ - std::vector get_incomplete_relations() const { - std::vector relations; - for (const auto& relation_meta : m_relations) { - if (!relation_meta.has_all_members()) { - relations.push_back(&get_relation(relation_meta)); - } - } - return relations; - } - - }; // class Collector - - } // namespace relations - -} // namespace osmium - -#endif // OSMIUM_RELATIONS_COLLECTOR_HPP +#ifndef OSMIUM_RELATIONS_COLLECTOR_HPP +#define OSMIUM_RELATIONS_COLLECTOR_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include // IWYU pragma: keep +#include +#include +#include +#include + +#include +#include + +namespace osmium { + + class Node; + class Way; + + /** + * @brief Code related to the assembly of OSM relations + */ + namespace relations { + + /** + * The Collector class collects members of a relation. This is a generic + * base class that can be used to assemble all kinds of relations. It has numerous + * hooks you can implement in derived classes to customize its behaviour. + * + * The collector provides two handlers (HandlerPass1 and HandlerPass2) for a first + * and second pass through an input file, respectively. In the first pass all + * relations we are interested in are stored in RelationMeta objects in the + * m_relations vector. All members we are interested in are stored in MemberMeta + * objects in the m_member_meta vectors. + * The MemberMeta objects also store the information where the relations containing + * those members are to be found. + * + * Later the m_member_meta vectors are sorted according to the + * member ids so that a binary search (with std::equal_range) can be used in the second + * pass to find the parent relations for each node, way, or relation coming along. + * The member objects are stored together with their relation and once a relation + * is complete the complete_relation() method is called which you must overwrite in + * a derived class of Collector. + * + * @tparam TCollector Derived class of this class. + * + * @tparam TNodes Are we interested in member nodes? + * + * @tparam TWays Are we interested in member ways? + * + * @tparam TRelations Are we interested in member relations? + */ + template + class Collector { + + /** + * This is the handler class for the first pass of the Collector. + */ + class HandlerPass1 : public osmium::handler::Handler { + + TCollector& m_collector; + + public: + + HandlerPass1(TCollector& collector) noexcept : + m_collector(collector) { + } + + void relation(const osmium::Relation& relation) { + if (m_collector.keep_relation(relation)) { + m_collector.add_relation(relation); + } + } + + }; // class HandlerPass1 + + /** + * This is the handler class for the second pass of the Collector. + */ + class HandlerPass2 : public osmium::handler::Handler { + + TCollector& m_collector; + + /** + * This variable is initialized with the number of different + * kinds of OSM objects we are interested in. If we only need + * way members (for instance for the multipolygon collector) + * it is intialized with 1 for instance. If node and way + * members are needed, it is initialized with 2. + * + * In the after_* methods of this handler, it is decremented + * and once it reaches 0, we know we have all members available + * that we are ever going to get. + */ + int m_want_types; + + /** + * Find this object in the member vectors and add it to all + * relations that need it. + * + * @returns true if the member was added to at least one + * relation and false otherwise + */ + bool find_and_add_object(const osmium::OSMObject& object) { + auto& mmv = m_collector.member_meta(object.type()); + auto range = std::equal_range(mmv.begin(), mmv.end(), MemberMeta(object.id())); + + if (osmium::relations::count_not_removed(range.first, range.second) == 0) { + // nothing found + return false; + } + + { + m_collector.members_buffer().add_item(object); + const size_t member_offset = m_collector.members_buffer().commit(); + + for (auto it = range.first; it != range.second; ++it) { + it->set_buffer_offset(member_offset); + } + } + + for (auto it = range.first; it != range.second; ++it) { + MemberMeta& member_meta = *it; + if (member_meta.removed()) { + break; + } + assert(member_meta.member_id() == object.id()); + assert(member_meta.relation_pos() < m_collector.m_relations.size()); + RelationMeta& relation_meta = m_collector.m_relations[member_meta.relation_pos()]; +// std::cerr << " => " << member_meta.member_pos() << " < " << m_collector.get_relation(relation_meta).members().size() << " (id=" << m_collector.get_relation(relation_meta).id() << ")\n"; + assert(member_meta.member_pos() < m_collector.get_relation(relation_meta).members().size()); +// std::cerr << " add way " << member_meta.member_id() << " to rel " << m_collector.get_relation(relation_meta).id() << " at pos " << member_meta.member_pos() << "\n"; + relation_meta.got_one_member(); + if (relation_meta.has_all_members()) { + const size_t relation_offset = member_meta.relation_pos(); + m_collector.complete_relation(relation_meta); + m_collector.m_relations[relation_offset] = RelationMeta(); + m_collector.possibly_purge_removed_members(); + } + } + + // Remove MemberMetas that were marked as removed. + mmv.erase(std::remove_if(mmv.begin(), mmv.end(), [](MemberMeta& mm) { + return mm.removed(); + }), mmv.end()); + + return true; + } + + public: + + HandlerPass2(TCollector& collector) noexcept : + m_collector(collector), + m_want_types((TNodes?1:0) + (TWays?1:0) + (TRelations?1:0)) { + } + + void node(const osmium::Node& node) { + if (TNodes) { + if (! find_and_add_object(node)) { + m_collector.node_not_in_any_relation(node); + } + } + } + + void way(const osmium::Way& way) { + if (TWays) { + if (! find_and_add_object(way)) { + m_collector.way_not_in_any_relation(way); + } + } + } + + void relation(const osmium::Relation& relation) { + if (TRelations) { + if (! find_and_add_object(relation)) { + m_collector.relation_not_in_any_relation(relation); + } + } + } + + void flush() { + m_collector.flush(); + } + + }; // class HandlerPass2 + + HandlerPass2 m_handler_pass2; + + // All relations we are interested in will be kept in this buffer + osmium::memory::Buffer m_relations_buffer; + + // All members we are interested in will be kept in this buffer + osmium::memory::Buffer m_members_buffer; + + /// Vector with all relations we are interested in + std::vector m_relations; + + /** + * One vector each for nodes, ways, and relations containing all + * mappings from member ids to their relations. + */ + std::vector m_member_meta[3]; + + int m_count_complete = 0; + + typedef std::function callback_func_type; + callback_func_type m_callback; + + static constexpr size_t initial_buffer_size = 1024 * 1024; + + public: + + /** + * Create an Collector. + */ + Collector() : + m_handler_pass2(*static_cast(this)), + m_relations_buffer(initial_buffer_size, osmium::memory::Buffer::auto_grow::yes), + m_members_buffer(initial_buffer_size, osmium::memory::Buffer::auto_grow::yes), + m_relations(), + m_member_meta() { + } + + protected: + + std::vector& member_meta(const item_type type) { + return m_member_meta[static_cast(type) - 1]; + } + + callback_func_type callback() { + return m_callback; + } + + const std::vector& relations() const { + return m_relations; + } + + /** + * This method is called from the first pass handler for every + * relation in the input, to check whether it should be kept. + * + * Overwrite this method in a child class to only add relations + * you are interested in, for instance depending on the type tag. + * Storing relations takes a lot of memory, so it makes sense to + * filter this as much as possible. + */ + bool keep_relation(const osmium::Relation& /*relation*/) const { + return true; + } + + /** + * This method is called for every member of every relation that + * should be kept. It should decide if the member is interesting or + * not and return true or false to signal that. Only interesting + * members are later added to the relation. + * + * Overwrite this method in a child class. In the MultiPolygonCollector + * this is for instance used to only keep members of type way and + * ignore all others. + */ + bool keep_member(const osmium::relations::RelationMeta& /*relation_meta*/, const osmium::RelationMember& /*member*/) const { + return true; + } + + /** + * This method is called for all nodes that are not a member of + * any relation. + * + * Overwrite this method in a child class if you are interested + * in this. + */ + void node_not_in_any_relation(const osmium::Node& /*node*/) { + } + + /** + * This method is called for all ways that are not a member of + * any relation. + * + * Overwrite this method in a child class if you are interested + * in this. + */ + void way_not_in_any_relation(const osmium::Way& /*way*/) { + } + + /** + * This method is called for all relations that are not a member of + * any relation. + * + * Overwrite this method in a child class if you are interested + * in this. + */ + void relation_not_in_any_relation(const osmium::Relation& /*relation*/) { + } + + /** + * This method is called from the 2nd pass handler when all objects + * of types we are interested in have been seen. + * + * Overwrite this method in a child class if you are interested + * in this. + * + * Note that even after this call members might be missing if they + * were not in the input file! The derived class has to handle this + * case. + */ + void flush() { + } + + /** + * This removes all relations that have already been assembled + * from the m_relations vector. + */ + void clean_assembled_relations() { + m_relations.erase( + std::remove_if(m_relations.begin(), m_relations.end(), has_all_members()), + m_relations.end() + ); + } + + const osmium::Relation& get_relation(size_t offset) const { + return m_relations_buffer.get(offset); + } + + /** + * Get the relation from a relation_meta. + */ + const osmium::Relation& get_relation(const RelationMeta& relation_meta) const { + return get_relation(relation_meta.relation_offset()); + } + + osmium::OSMObject& get_member(size_t offset) const { + return m_members_buffer.get(offset); + } + + /** + * Tell the Collector that you are interested in this relation + * and want it kept until all members have been assembled and + * it is handed back to you. + * + * The relation is copied and stored in a buffer inside the + * collector. + */ + void add_relation(const osmium::Relation& relation) { + const size_t offset = m_relations_buffer.committed(); + m_relations_buffer.add_item(relation); + + RelationMeta relation_meta(offset); + + int n=0; + for (auto& member : m_relations_buffer.get(offset).members()) { + if (static_cast(this)->keep_member(relation_meta, member)) { + member_meta(member.type()).emplace_back(member.ref(), m_relations.size(), n); + relation_meta.increment_need_members(); + } else { + member.ref(0); // set member id to zero to indicate we are not interested + } + ++n; + } + + assert(offset == m_relations_buffer.committed()); + if (relation_meta.has_all_members()) { + m_relations_buffer.rollback(); + } else { + m_relations_buffer.commit(); + m_relations.push_back(std::move(relation_meta)); +// std::cerr << "added relation id=" << relation.id() << "\n"; + } + } + + /** + * Sort the vectors with the member infos so that we can do binary + * search on them. + */ + void sort_member_meta() { +/* std::cerr << "relations: " << m_relations.size() << "\n"; + std::cerr << "node members: " << m_member_meta[0].size() << "\n"; + std::cerr << "way members: " << m_member_meta[1].size() << "\n"; + std::cerr << "relation members: " << m_member_meta[2].size() << "\n";*/ + std::sort(m_member_meta[0].begin(), m_member_meta[0].end()); + std::sort(m_member_meta[1].begin(), m_member_meta[1].end()); + std::sort(m_member_meta[2].begin(), m_member_meta[2].end()); + } + + public: + + uint64_t used_memory() const { + const uint64_t nmembers = m_member_meta[0].capacity() + m_member_meta[1].capacity() + m_member_meta[2].capacity(); + const uint64_t members = nmembers * sizeof(MemberMeta); + const uint64_t relations = m_relations.capacity() * sizeof(RelationMeta); + const uint64_t relations_buffer_capacity = m_relations_buffer.capacity(); + const uint64_t members_buffer_capacity = m_members_buffer.capacity(); + + std::cout << " nR = m_relations.capacity() ........... = " << std::setw(12) << m_relations.capacity() << "\n"; + std::cout << " nMN = m_member_meta[NODE].capacity() ... = " << std::setw(12) << m_member_meta[0].capacity() << "\n"; + std::cout << " nMW = m_member_meta[WAY].capacity() .... = " << std::setw(12) << m_member_meta[1].capacity() << "\n"; + std::cout << " nMR = m_member_meta[RELATION].capacity() = " << std::setw(12) << m_member_meta[2].capacity() << "\n"; + std::cout << " nM = m_member_meta[*].capacity() ...... = " << std::setw(12) << nmembers << "\n"; + + std::cout << " sRM = sizeof(RelationMeta) ............. = " << std::setw(12) << sizeof(RelationMeta) << "\n"; + std::cout << " sMM = sizeof(MemberMeta) ............... = " << std::setw(12) << sizeof(MemberMeta) << "\n\n"; + + std::cout << " nR * sRM ............................... = " << std::setw(12) << relations << "\n"; + std::cout << " nM * sMM ............................... = " << std::setw(12) << members << "\n"; + std::cout << " relations_buffer_capacity .............. = " << std::setw(12) << relations_buffer_capacity << "\n"; + std::cout << " members_buffer_capacity ................ = " << std::setw(12) << members_buffer_capacity << "\n"; + + const uint64_t total = relations + members + relations_buffer_capacity + members_buffer_capacity; + + std::cout << " total .................................. = " << std::setw(12) << total << "\n"; + std::cout << " =======================================================\n"; + + return relations_buffer_capacity + members_buffer_capacity + relations + members; + } + + /** + * Return reference to second pass handler. + */ + HandlerPass2& handler(const callback_func_type& callback = nullptr) { + m_callback = callback; + return m_handler_pass2; + } + + osmium::memory::Buffer& members_buffer() { + return m_members_buffer; + } + + size_t get_offset(osmium::item_type type, osmium::object_id_type id) { + const auto& mmv = member_meta(type); + const auto range = std::equal_range(mmv.cbegin(), mmv.cend(), MemberMeta(id)); + assert(range.first != range.second); + return range.first->buffer_offset(); + } + + template + void read_relations(TIter begin, TIter end) { + HandlerPass1 handler(*static_cast(this)); + osmium::apply(begin, end, handler); + sort_member_meta(); + } + + template + void read_relations(TSource& source) { + read_relations(std::begin(source), std::end(source)); + source.close(); + } + + void moving_in_buffer(size_t old_offset, size_t new_offset) { + const osmium::OSMObject& object = m_members_buffer.get(old_offset); + auto& mmv = member_meta(object.type()); + auto range = std::equal_range(mmv.begin(), mmv.end(), osmium::relations::MemberMeta(object.id())); + for (auto it = range.first; it != range.second; ++it) { + assert(it->buffer_offset() == old_offset); + it->set_buffer_offset(new_offset); + } + } + + /** + * Decide whether to purge removed members and then do it. + * + * Currently the purging is done every thousand calls. + * This could probably be improved upon. + */ + void possibly_purge_removed_members() { + ++m_count_complete; + if (m_count_complete > 10000) { // XXX + const size_t size_before = m_members_buffer.committed(); + m_members_buffer.purge_removed(this); + const size_t size_after = m_members_buffer.committed(); + double percent = size_before - size_after; + percent /= size_before; + percent *= 100; + std::cerr << "PURGE (size before=" << size_before << " after=" << size_after << " purged=" << (size_before - size_after) << " / " << static_cast(percent) << "%)\n"; + m_count_complete = 0; + } + } + + /** + * Get a vector with pointers to all Relations that could not + * be completed, because members were missing in the input + * data. + * + * Note that these pointers point into memory allocated and + * owned by the Collector object. + */ + std::vector get_incomplete_relations() const { + std::vector relations; + for (const auto& relation_meta : m_relations) { + if (!relation_meta.has_all_members()) { + relations.push_back(&get_relation(relation_meta)); + } + } + return relations; + } + + }; // class Collector + + } // namespace relations + +} // namespace osmium + +#endif // OSMIUM_RELATIONS_COLLECTOR_HPP diff --git a/ThirdParty/osmium/relations/detail/member_meta.hpp b/ThirdParty/osmium/relations/detail/member_meta.hpp index f6105e559..5463a1cb8 100644 --- a/ThirdParty/osmium/relations/detail/member_meta.hpp +++ b/ThirdParty/osmium/relations/detail/member_meta.hpp @@ -1,131 +1,158 @@ -#ifndef OSMIUM_RELATIONS_DETAIL_MEMBER_META_HPP -#define OSMIUM_RELATIONS_DETAIL_MEMBER_META_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 -#include - -#include - -namespace osmium { - - namespace relations { - - /** - * Helper class for the Collector class. - * - * Stores an object ID and information where the object should be - * stored. - */ - class MemberMeta { - - /** - * Object ID of this relation member. Can be a node, way, or relation ID. - * It depends on the vector in which this object is stored which kind of - * object is referenced here. - */ - osmium::object_id_type m_member_id; - - /** - * Position of the relation this member is a part of in the - * m_relations vector. - */ - size_t m_relation_pos; - - /** - * Position of this member in the list of members of the - * relation this member is a part of. - */ - size_t m_member_pos; - - /** - * Offset in the buffer where the object is stored. - */ - size_t m_buffer_offset { 0 }; - - public: - - /** - * Create new MemberMeta. The variant with zeros for relation_pos and - * member_pos is used to create dummy MemberMeta that can be compared - * to the MemberMeta in the vectors using the equal_range algorithm. - */ - explicit MemberMeta(osmium::object_id_type member_id, size_t relation_pos=0, size_t member_pos=0) : - m_member_id(member_id), - m_relation_pos(relation_pos), - m_member_pos(member_pos) { - } - - osmium::object_id_type member_id() const { - return m_member_id; - } - - size_t relation_pos() const { - return m_relation_pos; - } - - size_t member_pos() const { - return m_member_pos; - } - - size_t buffer_offset() const { - return m_buffer_offset; - } - - void buffer_offset(size_t offset) { - m_buffer_offset = offset; - } - - }; // class MemberMeta - - /** - * Compares two MemberMeta objects by only looking at the member id. - * Used to sort a vector of MemberMeta objects and to later find - * them using binary search. - */ - inline bool operator<(const MemberMeta& a, const MemberMeta& b) { - return a.member_id() < b.member_id(); - } - - template - inline std::basic_ostream& operator<<(std::basic_ostream& out, const MemberMeta& mm) { - out << "MemberMeta(member_id=" << mm.member_id() << " relation_pos=" << mm.relation_pos() << " member_pos=" << mm.member_pos() << " buffer_offset=" << mm.buffer_offset() << ")"; - return out; - } - - } // namespace relations - -} // namespace osmium - -#endif // OSMIUM_RELATIONS_DETAIL_MEMBER_META_HPP +#ifndef OSMIUM_RELATIONS_DETAIL_MEMBER_META_HPP +#define OSMIUM_RELATIONS_DETAIL_MEMBER_META_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include + +#include + +namespace osmium { + + namespace relations { + + /** + * Helper class for the Collector class. + * + * Stores an object ID and information where the object should be + * stored. + */ + class MemberMeta { + + /** + * Object ID of this relation member. Can be a node, way, or relation ID. + * It depends on the vector in which this object is stored which kind of + * object is referenced here. + */ + osmium::object_id_type m_member_id; + + /** + * Position of the relation this member is a part of in the + * m_relations vector. + */ + size_t m_relation_pos; + + /** + * Position of this member in the list of members of the + * relation this member is a part of. + */ + size_t m_member_pos; + + /** + * Offset in the buffer where the object is stored. + */ + size_t m_buffer_offset { 0 }; + + bool m_removed = false; + + public: + + /** + * Create new MemberMeta. The variant with zeros for relation_pos and + * member_pos is used to create dummy MemberMeta that can be compared + * to the MemberMeta in the vectors using the equal_range algorithm. + */ + explicit MemberMeta(osmium::object_id_type member_id, size_t relation_pos=0, size_t member_pos=0) noexcept : + m_member_id(member_id), + m_relation_pos(relation_pos), + m_member_pos(member_pos) { + } + + osmium::object_id_type member_id() const noexcept { + return m_member_id; + } + + size_t relation_pos() const noexcept { + return m_relation_pos; + } + + size_t member_pos() const noexcept { + return m_member_pos; + } + + size_t buffer_offset() const noexcept { + return m_buffer_offset; + } + + void set_buffer_offset(size_t offset) noexcept { + m_buffer_offset = offset; + } + + bool removed() const noexcept { + return m_removed; + } + + void remove() noexcept { + m_removed = true; + } + + }; // class MemberMeta + + /** + * Compares two MemberMeta objects by only looking at the member id. + * Used to sort a vector of MemberMeta objects and to later find + * them using binary search. + */ + inline bool operator<(const MemberMeta& a, const MemberMeta& b) noexcept { + return a.member_id() < b.member_id(); + } + + template + inline std::basic_ostream& operator<<(std::basic_ostream& out, const MemberMeta& mm) { + out << "MemberMeta(member_id=" << mm.member_id() << " relation_pos=" << mm.relation_pos() << " member_pos=" << mm.member_pos() << " buffer_offset=" << mm.buffer_offset() << ")"; + return out; + } + + /** + * Count the number of MemberMeta objects in the iterator range + * that are not marked as removed. + * + * @tparam TIter Iterator that dereferences to a MemberMeta + * @param begin Begin of iterator range + * @param end End of iterator range + */ + template + inline typename std::iterator_traits::difference_type count_not_removed(TIter begin, TIter end) { + return std::count_if(begin, end, [](MemberMeta& mm) { + return !mm.removed(); + }); + } + + } // namespace relations + +} // namespace osmium + +#endif // OSMIUM_RELATIONS_DETAIL_MEMBER_META_HPP diff --git a/ThirdParty/osmium/relations/detail/relation_meta.hpp b/ThirdParty/osmium/relations/detail/relation_meta.hpp index a9b184ea6..77ca0c130 100644 --- a/ThirdParty/osmium/relations/detail/relation_meta.hpp +++ b/ThirdParty/osmium/relations/detail/relation_meta.hpp @@ -1,136 +1,136 @@ -#ifndef OSMIUM_RELATIONS_DETAIL_RELATION_META_HPP -#define OSMIUM_RELATIONS_DETAIL_RELATION_META_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 -#include -#include - -namespace osmium { - - namespace relations { - - /** - * Helper class for the Collector class. - * - * Stores information needed to collect all members of a relation. This - * includes the offset of the relation in a buffer plus the information - * needed to add members to this relation. - */ - class RelationMeta { - - /// The relation we are assembling. - size_t m_relation_offset; - - /** - * The number of members still needed before the relation is complete. - * This will be set to the number of members we are interested in and - * then count down for every member we find. When it is 0, the relation - * is complete. - */ - int m_need_members = 0; - - public: - - /** - * Initialize an empty RelationMeta. This is needed to zero out relations - * that have been completed. - */ - RelationMeta() : - m_relation_offset(0) { - } - - explicit RelationMeta(size_t relation_offset) : - m_relation_offset(relation_offset) { - } - - /** - * Get offset of relation in buffer. - */ - size_t relation_offset() const { - return m_relation_offset; - } - - /** - * Increment the m_need_members counter. - */ - void increment_need_members() { - ++m_need_members; - } - - /** - * This decrements the "members needed" counter. - */ - void got_one_member() { - assert(m_need_members > 0); - --m_need_members; - } - - /** - * Returns true if all members for this relation are available. - */ - bool has_all_members() const { - return m_need_members == 0; - } - - }; // class RelationMeta - - template - inline std::basic_ostream& operator<<(std::basic_ostream& out, const RelationMeta& rm) { - out << "RelationMeta(relation_offset=" << rm.relation_offset() << " has_all_members=" << rm.has_all_members() << ")"; - return out; - } - - /** - * Function object to check if a relation is complete. - */ - struct has_all_members { - - typedef RelationMeta& argument_type; - typedef bool result_type; - - /** - * @return true if this relation is complete, false otherwise. - */ - bool operator()(RelationMeta& relation_info) const { - return relation_info.has_all_members(); - } - - }; // struct has_all_members - - } // namespace relations - -} // namespace osmium - -#endif // OSMIUM_RELATIONS_DETAIL_RELATION_META_HPP +#ifndef OSMIUM_RELATIONS_DETAIL_RELATION_META_HPP +#define OSMIUM_RELATIONS_DETAIL_RELATION_META_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include + +namespace osmium { + + namespace relations { + + /** + * Helper class for the Collector class. + * + * Stores information needed to collect all members of a relation. This + * includes the offset of the relation in a buffer plus the information + * needed to add members to this relation. + */ + class RelationMeta { + + /// The relation we are assembling. + size_t m_relation_offset; + + /** + * The number of members still needed before the relation is + * complete. This will be set to the number of members we are + * interested in and then count down for every member we find. + * When it is 0, the relation is complete. + */ + int m_need_members = 0; + + public: + + /** + * Initialize an empty RelationMeta. This is needed to zero out + * relations that have been completed. + */ + RelationMeta() noexcept : + m_relation_offset(0) { + } + + explicit RelationMeta(size_t relation_offset) noexcept : + m_relation_offset(relation_offset) { + } + + /** + * Get offset of relation in buffer. + */ + size_t relation_offset() const noexcept { + return m_relation_offset; + } + + /** + * Increment the m_need_members counter. + */ + void increment_need_members() noexcept { + ++m_need_members; + } + + /** + * This decrements the "members needed" counter. + */ + void got_one_member() { + assert(m_need_members > 0); + --m_need_members; + } + + /** + * Returns true if all members for this relation are available. + */ + bool has_all_members() const noexcept { + return m_need_members == 0; + } + + }; // class RelationMeta + + template + inline std::basic_ostream& operator<<(std::basic_ostream& out, const RelationMeta& rm) { + out << "RelationMeta(relation_offset=" << rm.relation_offset() << " has_all_members=" << rm.has_all_members() << ")"; + return out; + } + + /** + * Function object to check if a relation is complete. + */ + struct has_all_members { + + typedef RelationMeta& argument_type; + typedef bool result_type; + + /** + * @returns true if this relation is complete, false otherwise. + */ + bool operator()(RelationMeta& relation_info) const { + return relation_info.has_all_members(); + } + + }; // struct has_all_members + + } // namespace relations + +} // namespace osmium + +#endif // OSMIUM_RELATIONS_DETAIL_RELATION_META_HPP diff --git a/ThirdParty/osmium/tags/filter.hpp b/ThirdParty/osmium/tags/filter.hpp index a55dcf718..0a0fd3b56 100644 --- a/ThirdParty/osmium/tags/filter.hpp +++ b/ThirdParty/osmium/tags/filter.hpp @@ -51,27 +51,27 @@ namespace osmium { bool operator()(const TKey& rule_key, const char* tag_key) { return rule_key == tag_key; } - }; + }; // struct match_key struct match_key_prefix { bool operator()(const std::string& rule_key, const char* tag_key) { return rule_key.compare(0, std::string::npos, tag_key, 0, rule_key.size()) == 0; } - }; + }; // struct match_key_prefix template struct match_value { bool operator()(const TValue& rule_value, const char* tag_value) { return rule_value == tag_value; } - }; + }; // struct match_value template <> struct match_value { bool operator()(const bool, const char*) { return true; } - }; + }; // struct match_value template , class TValueComp=match_value> class Filter { @@ -99,7 +99,7 @@ namespace osmium { result(r) { } - }; + }; // struct Rule std::vector m_rules; bool m_default_result; @@ -135,7 +135,7 @@ namespace osmium { return m_default_result; } - }; // Filter + }; // class Filter typedef Filter KeyValueFilter; typedef Filter KeyFilter; diff --git a/ThirdParty/osmium/tags/regex_filter.hpp b/ThirdParty/osmium/tags/regex_filter.hpp index 1f30cba7a..ae2703a30 100644 --- a/ThirdParty/osmium/tags/regex_filter.hpp +++ b/ThirdParty/osmium/tags/regex_filter.hpp @@ -1,58 +1,58 @@ -#ifndef OSMIUM_TAGS_REGEX_FILTER_HPP -#define OSMIUM_TAGS_REGEX_FILTER_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2014 Jochen Topf 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 -#include - -#include - -namespace osmium { - - namespace tags { - - template <> - struct match_value { - bool operator()(const std::regex& rule_value, const char* tag_value) { - return std::regex_match(tag_value, rule_value); - } - }; - - typedef Filter RegexFilter; - - } // namespace tags - -} // namespace osmium - -#endif // OSMIUM_TAGS_REGEX_FILTER_HPP +#ifndef OSMIUM_TAGS_REGEX_FILTER_HPP +#define OSMIUM_TAGS_REGEX_FILTER_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2014 Jochen Topf 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 +#include + +#include + +namespace osmium { + + namespace tags { + + template <> + struct match_value { + bool operator()(const std::regex& rule_value, const char* tag_value) { + return std::regex_match(tag_value, rule_value); + } + }; // struct match_value + + typedef Filter RegexFilter; + + } // namespace tags + +} // namespace osmium + +#endif // OSMIUM_TAGS_REGEX_FILTER_HPP diff --git a/ThirdParty/osmium/thread/function_wrapper.hpp b/ThirdParty/osmium/thread/function_wrapper.hpp index ad0d14d49..22043ffb5 100644 --- a/ThirdParty/osmium/thread/function_wrapper.hpp +++ b/ThirdParty/osmium/thread/function_wrapper.hpp @@ -1,104 +1,104 @@ -#ifndef OSMIUM_THREAD_FUNCTION_WRAPPER_HPP -#define OSMIUM_THREAD_FUNCTION_WRAPPER_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 -#include - -namespace osmium { - - namespace thread { - - class function_wrapper { - - struct impl_base { - virtual void call() = 0; - virtual ~impl_base() { - } - }; - - std::unique_ptr impl; - - template - struct impl_type : impl_base { - F m_functor; - - impl_type(F&& functor) : - m_functor(std::move(functor)) { - } - - void call() { - m_functor(); - } - }; - - public: - - // Constructor must not be "explicit" for wrapper - // to work seemlessly. - template - function_wrapper(F&& f) : - impl(new impl_type(std::move(f))) { - } - - void operator()() { - impl->call(); - } - - function_wrapper() = default; - - function_wrapper(function_wrapper&& other) : - impl(std::move(other.impl)) { - } - - function_wrapper& operator=(function_wrapper&& other) { - impl = std::move(other.impl); - return *this; - } - - function_wrapper(const function_wrapper&) = delete; - function_wrapper(function_wrapper&) = delete; - function_wrapper& operator=(const function_wrapper&) = delete; - - explicit operator bool() const { - return static_cast(impl); - } - - }; // class function_wrapper - - } // namespace thread - -} // namespace osmium - -#endif // OSMIUM_THREAD_FUNCTION_WRAPPER_HPP +#ifndef OSMIUM_THREAD_FUNCTION_WRAPPER_HPP +#define OSMIUM_THREAD_FUNCTION_WRAPPER_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include + +namespace osmium { + + namespace thread { + + class function_wrapper { + + struct impl_base { + virtual void call() = 0; + virtual ~impl_base() { + } + }; // struct impl_base + + std::unique_ptr impl; + + template + struct impl_type : impl_base { + F m_functor; + + impl_type(F&& functor) : + m_functor(std::move(functor)) { + } + + void call() { + m_functor(); + } + }; // struct impl_type + + public: + + // Constructor must not be "explicit" for wrapper + // to work seemlessly. + template + function_wrapper(F&& f) : + impl(new impl_type(std::move(f))) { + } + + void operator()() { + impl->call(); + } + + function_wrapper() = default; + + function_wrapper(function_wrapper&& other) : + impl(std::move(other.impl)) { + } + + function_wrapper& operator=(function_wrapper&& other) { + impl = std::move(other.impl); + return *this; + } + + function_wrapper(const function_wrapper&) = delete; + function_wrapper(function_wrapper&) = delete; + function_wrapper& operator=(const function_wrapper&) = delete; + + explicit operator bool() const { + return static_cast(impl); + } + + }; // class function_wrapper + + } // namespace thread + +} // namespace osmium + +#endif // OSMIUM_THREAD_FUNCTION_WRAPPER_HPP diff --git a/ThirdParty/osmium/thread/pool.hpp b/ThirdParty/osmium/thread/pool.hpp index 2e6d6356f..58fd53edd 100644 --- a/ThirdParty/osmium/thread/pool.hpp +++ b/ThirdParty/osmium/thread/pool.hpp @@ -1,180 +1,204 @@ -#ifndef OSMIUM_THREAD_POOL_HPP -#define OSMIUM_THREAD_POOL_HPP - -/* - -This file is part of Osmium (http://osmcode.org/libosmium). - -Copyright 2013,2014 Jochen Topf 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 -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include - -namespace osmium { - - /** - * @brief Threading-related low-level code - */ - namespace thread { - - /** - * Thread pool. - */ - class Pool { - - // This class makes sure pool threads are joined when the pool is destructed - class thread_joiner { - - std::vector& m_threads; - - public: - - explicit thread_joiner(std::vector& threads) : - m_threads(threads) { - } - - ~thread_joiner() { - for (auto& thread : m_threads) { - if (thread.joinable()) { - thread.join(); - } - } - } - - }; // class thread_joiner - - std::atomic m_done; - osmium::thread::Queue m_work_queue; - std::vector m_threads; - thread_joiner m_joiner; - int m_num_threads; - - void worker_thread() { - osmium::thread::set_thread_name("_osmium_worker"); - while (!m_done) { - function_wrapper task; - m_work_queue.wait_and_pop_with_timeout(task); - if (task) { - task(); - } - } - } - - /** - * Create thread pool with the given number of threads. If - * num_threads is 0, the number of threads is read from - * the environment variable OSMIUM_POOL_THREADS. The default - * value in that case is -2. - * - * If the number of threads is a negative number, it will be - * set to the actual number of cores on the system plus the - * given number, ie it will leave a number of cores unused. - * - * In all cases the minimum number of threads in the pool is 1. - */ - explicit Pool(int num_threads) : - m_done(false), - m_work_queue(), - m_threads(), - m_joiner(m_threads), - m_num_threads(num_threads) { - - if (m_num_threads == 0) { - const char* env_threads = getenv("OSMIUM_POOL_THREADS"); - if (env_threads) { - m_num_threads = std::atoi(env_threads); - } else { - m_num_threads = -2; - } - } - - if (m_num_threads <= 0) { - m_num_threads = std::max(1, static_cast(std::thread::hardware_concurrency()) + m_num_threads); - } - - try { - for (int i=0; i < m_num_threads; ++i) { - m_threads.push_back(std::thread(&Pool::worker_thread, this)); - } - } catch (...) { - m_done = true; - throw; - } - } - - public: - - static constexpr int default_num_threads = 0; - - static Pool& instance() { - static Pool pool(default_num_threads); - return pool; - } - - ~Pool() { - m_done = true; - } - - size_t queue_size() const { - return m_work_queue.size(); - } - - bool queue_empty() const { - return m_work_queue.empty(); - } - - template - std::future::type> submit(TFunction f) { - - typedef typename std::result_of::type result_type; - - std::packaged_task task(std::move(f)); - std::future future_result(task.get_future()); - m_work_queue.push(std::move(task)); - - return future_result; - } - - }; // class Pool - - } // namespace thread - -} // namespace osmium - -#endif // OSMIUM_THREAD_POOL_HPP +#ifndef OSMIUM_THREAD_POOL_HPP +#define OSMIUM_THREAD_POOL_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +namespace osmium { + + /** + * @brief Threading-related low-level code + */ + namespace thread { + + /** + * Thread pool. + */ + class Pool { + + // This class makes sure pool threads are joined when the pool is destructed + class thread_joiner { + + std::vector& m_threads; + + public: + + explicit thread_joiner(std::vector& threads) : + m_threads(threads) { + } + + ~thread_joiner() { + for (auto& thread : m_threads) { + if (thread.joinable()) { + thread.join(); + } + } + } + + }; // class thread_joiner + + std::atomic m_done; + osmium::thread::Queue m_work_queue; + std::vector m_threads; + thread_joiner m_joiner; + int m_num_threads; + + void worker_thread() { + osmium::thread::set_thread_name("_osmium_worker"); + while (!m_done) { + function_wrapper task; + m_work_queue.wait_and_pop_with_timeout(task); + if (task) { + task(); + } + } + } + + /** + * Create thread pool with the given number of threads. If + * num_threads is 0, the number of threads is read from + * the environment variable OSMIUM_POOL_THREADS. The default + * value in that case is -2. + * + * If the number of threads is a negative number, it will be + * set to the actual number of cores on the system plus the + * given number, ie it will leave a number of cores unused. + * + * In all cases the minimum number of threads in the pool is 1. + */ + explicit Pool(int num_threads) : + m_done(false), + m_work_queue(), + m_threads(), + m_joiner(m_threads), + m_num_threads(num_threads) { + + if (m_num_threads == 0) { + const char* env_threads = getenv("OSMIUM_POOL_THREADS"); + if (env_threads) { + m_num_threads = std::atoi(env_threads); + } else { + m_num_threads = -2; + } + } + + if (m_num_threads <= 0) { + m_num_threads = std::max(1, static_cast(std::thread::hardware_concurrency()) + m_num_threads); + } + + try { + for (int i=0; i < m_num_threads; ++i) { + m_threads.push_back(std::thread(&Pool::worker_thread, this)); + } + } catch (...) { + m_done = true; + throw; + } + } + + public: + + static constexpr int default_num_threads = 0; + + static Pool& instance() { + static Pool pool(default_num_threads); + return pool; + } + + ~Pool() { + m_done = true; + } + + size_t queue_size() const { + return m_work_queue.size(); + } + + bool queue_empty() const { + return m_work_queue.empty(); + } + + template + std::future::type> submit(TFunction f) { + + typedef typename std::result_of::type result_type; + + std::packaged_task task(std::move(f)); + std::future future_result(task.get_future()); + m_work_queue.push(std::move(task)); + + return future_result; + } + + }; // class Pool + + /** + * Wrapper for classes that can't be copied but need to be copyable for + * putting them in the pool. + */ + template + class SharedPtrWrapper { + + std::shared_ptr m_task; + + public: + + typedef typename std::result_of::type result_type; + + template + SharedPtrWrapper(TArgs&&... args) : + m_task(std::make_shared(std::forward(args)...)) { + } + + result_type operator()() { + return m_task->operator()(); + } + + }; // class SharedPtrWrapper + + } // namespace thread + +} // namespace osmium + +#endif // OSMIUM_THREAD_POOL_HPP diff --git a/ThirdParty/osmium/util/compatibility.hpp b/ThirdParty/osmium/util/compatibility.hpp index dfd854cc3..48a6db017 100644 --- a/ThirdParty/osmium/util/compatibility.hpp +++ b/ThirdParty/osmium/util/compatibility.hpp @@ -1,5 +1,5 @@ -#ifndef OSMIUM_CONFIG_CONSTEXPR_HPP -#define OSMIUM_CONFIG_CONSTEXPR_HPP +#ifndef OSMIUM_UTIL_COMPATIBILITY_HPP +#define OSMIUM_UTIL_COMPATIBILITY_HPP /* @@ -44,4 +44,4 @@ DEALINGS IN THE SOFTWARE. # define OSMIUM_NORETURN [[noreturn]] #endif -#endif // OSMIUM_CONFIG_CONSTEXPR_HPP +#endif // OSMIUM_UTIL_COMPATIBILITY_HPP diff --git a/ThirdParty/osmium/util/verbose_output.hpp b/ThirdParty/osmium/util/verbose_output.hpp index 9925ceee4..8709441af 100644 --- a/ThirdParty/osmium/util/verbose_output.hpp +++ b/ThirdParty/osmium/util/verbose_output.hpp @@ -87,7 +87,7 @@ namespace osmium { public: - explicit VerboseOutput(bool verbose=false) : + explicit VerboseOutput(bool verbose=false) noexcept : m_start(time(NULL)), m_verbose(verbose), m_newline(true) { From 428bb36ec6bc819fbfc5ae3fecaa5bedc0d5d4f1 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Tue, 18 Nov 2014 16:54:48 +0100 Subject: [PATCH 70/80] parallelize with a vector of iterators --- Extractor/Extractor.cpp | 102 +++++++++++++++++++++++-------- Extractor/ExtractorCallbacks.cpp | 8 +-- Extractor/RestrictionParser.cpp | 14 ++--- Extractor/RestrictionParser.h | 14 ++--- 4 files changed, 96 insertions(+), 42 deletions(-) diff --git a/Extractor/Extractor.cpp b/Extractor/Extractor.cpp index c5e3817cf..13e82ba29 100644 --- a/Extractor/Extractor.cpp +++ b/Extractor/Extractor.cpp @@ -49,12 +49,14 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include +#include #include #include #include +#include #include #include #include @@ -116,16 +118,22 @@ int Extractor::Run(int argc, char *argv[]) SimpleLogger().Write() << "Input file: " << extractor_config.input_path.filename().string(); SimpleLogger().Write() << "Profile: " << extractor_config.profile_path.filename().string(); SimpleLogger().Write() << "Threads: " << extractor_config.requested_num_threads; - if (recommended_num_threads != extractor_config.requested_num_threads) - { - SimpleLogger().Write(logWARNING) << "The recommended number of threads is " - << recommended_num_threads - << "! This setting may have performance side-effects."; - } + // if (recommended_num_threads != extractor_config.requested_num_threads) + // { + // SimpleLogger().Write(logWARNING) << "The recommended number of threads is " + // << recommended_num_threads + // << "! This setting may have performance side-effects."; + // } - tbb::task_scheduler_init init(extractor_config.requested_num_threads); + auto number_of_threads = std::max(1, + std::min(static_cast(recommended_num_threads), static_cast(extractor_config.requested_num_threads)) ); - /*** Setup Scripting Environment ***/ + tbb::task_scheduler_init init(number_of_threads); + + SimpleLogger().Write() << "requested_num_threads: " << extractor_config.requested_num_threads; + SimpleLogger().Write() << "number_of_threads: " << number_of_threads; + + // setup scripting environment ScriptingEnvironment scripting_environment(extractor_config.profile_path.string().c_str()); std::unordered_map string_map; @@ -166,48 +174,94 @@ int Extractor::Run(int argc, char *argv[]) timestamp_out.write(timestamp.c_str(), timestamp.length()); timestamp_out.close(); - lua_State *lua_state = scripting_environment.getLuaState(); + // lua_State *lua_state = scripting_environment.getLuaState(); luabind::set_pcall_callback(&lua_error_callback); - RestrictionParser restriction_parser(scripting_environment); - - ExtractionNode result_node; - ExtractionWay result_way; + // initialize vectors holding parsed objects + tbb::concurrent_vector> resulting_nodes; + tbb::concurrent_vector> resulting_ways; + tbb::concurrent_vector> resulting_restrictions; while (osmium::memory::Buffer buffer = reader.read()) { - for (osmium::OSMEntity &entity : buffer) + // create a vector of iterators into the buffer + std::vector elements; + osmium::memory::Buffer::iterator iter = std::begin(buffer); + while(iter != std::end(buffer)) { - switch (entity.type()) + elements.push_back(iter); + iter = std::next(iter); + } + + // clear resulting vectors + resulting_nodes.clear(); + resulting_ways.clear(); + resulting_restrictions.clear(); + + // SimpleLogger().Write(logDEBUG) << "elements count: " << elements.size(); + + // parse OSM entities in parallel, store in resulting vectors + tbb::parallel_for(tbb::blocked_range(0, elements.size()), + [&](const tbb::blocked_range& range) + { + for (auto x = range.begin(); x != range.end(); ++x) + { + auto entity = elements[x]; + + ExtractionNode result_node; + ExtractionWay result_way; + // RestrictionParser restriction_parser(scripting_environment); + + switch (entity->type()) { case osmium::item_type::node: ++number_of_nodes; result_node.Clear(); - luabind::call_function(lua_state, + luabind::call_function(scripting_environment.getLuaState(), "node_function", - boost::cref(static_cast(entity)), + boost::cref(static_cast(*entity)), boost::ref(result_node)); - extractor_callbacks->ProcessNode(static_cast(entity), - result_node); + resulting_nodes.emplace_back(x, result_node); + // extractor_callbacks->ProcessNode(static_cast(*entity), + // result_node); break; case osmium::item_type::way: ++number_of_ways; result_way.Clear(); - luabind::call_function(lua_state, + luabind::call_function(scripting_environment.getLuaState(), "way_function", - boost::cref(static_cast(entity)), + boost::cref(static_cast(*entity)), boost::ref(result_way)); - extractor_callbacks->ProcessWay(static_cast(entity), result_way); + resulting_ways.emplace_back(x, result_way); + // extractor_callbacks->ProcessWay(static_cast(*entity), result_way); break; case osmium::item_type::relation: ++number_of_relations; - extractor_callbacks->ProcessRestriction( - restriction_parser.TryParse(static_cast(entity))); + // resulting_restrictions.emplace_back(restriction_parser.TryParse(static_cast(*entity))); + // extractor_callbacks->ProcessRestriction(restriction_parser.TryParse(static_cast(*entity))); break; default: ++number_of_others; break; } + } + } + ); + + // put parsed objects thru extractor callbacks + for (const auto &result : resulting_nodes) + { + extractor_callbacks->ProcessNode(static_cast(*(elements[result.first])), + result.second); + } + for (const auto &result : resulting_ways) + { + extractor_callbacks->ProcessWay(static_cast(*(elements[result.first])), + result.second); + } + for (const auto &result : resulting_restrictions) + { + extractor_callbacks->ProcessRestriction(result); } } TIMER_STOP(parsing); diff --git a/Extractor/ExtractorCallbacks.cpp b/Extractor/ExtractorCallbacks.cpp index df56d7fd3..5f398dc8a 100644 --- a/Extractor/ExtractorCallbacks.cpp +++ b/Extractor/ExtractorCallbacks.cpp @@ -66,10 +66,10 @@ void ExtractorCallbacks::ProcessRestriction( if (restriction) { external_memory.restrictions_list.push_back(restriction.get()); - SimpleLogger().Write() << "from: " << restriction.get().restriction.from.node << - ",via: " << restriction.get().restriction.via.node << - ", to: " << restriction.get().restriction.to.node << - ", only: " << (restriction.get().restriction.flags.is_only ? "y" : "n"); + // SimpleLogger().Write() << "from: " << restriction.get().restriction.from.node << + // ",via: " << restriction.get().restriction.via.node << + // ", to: " << restriction.get().restriction.to.node << + // ", only: " << (restriction.get().restriction.flags.is_only ? "y" : "n"); } } /** warning: caller needs to take care of synchronization! */ diff --git a/Extractor/RestrictionParser.cpp b/Extractor/RestrictionParser.cpp index 690ad82ac..ac0931a24 100644 --- a/Extractor/RestrictionParser.cpp +++ b/Extractor/RestrictionParser.cpp @@ -51,18 +51,18 @@ int lua_error_callback(lua_State *L) } } -RestrictionParser::RestrictionParser(ScriptingEnvironment &scripting_environment) - : lua_state(scripting_environment.getLuaState()), use_turn_restrictions(true) +RestrictionParser::RestrictionParser(lua_State *lua_state) + : /*lua_state(scripting_environment.getLuaState()),*/ use_turn_restrictions(true) { - ReadUseRestrictionsSetting(); + ReadUseRestrictionsSetting(lua_state); if (use_turn_restrictions) { - ReadRestrictionExceptions(); + ReadRestrictionExceptions(lua_state); } } -void RestrictionParser::ReadUseRestrictionsSetting() +void RestrictionParser::ReadUseRestrictionsSetting(lua_State *lua_state) { if (0 == luaL_dostring(lua_state, "return use_turn_restrictions\n")) { @@ -82,7 +82,7 @@ void RestrictionParser::ReadUseRestrictionsSetting() } } -void RestrictionParser::ReadRestrictionExceptions() +void RestrictionParser::ReadRestrictionExceptions(lua_State *lua_state) { if (lua_function_exists(lua_state, "get_exceptions")) { @@ -104,7 +104,7 @@ void RestrictionParser::ReadRestrictionExceptions() } } -mapbox::util::optional RestrictionParser::TryParse(osmium::Relation &relation) const +mapbox::util::optional RestrictionParser::TryParse(lua_State *lua_state, osmium::Relation &relation) const { // return if turn restrictions should be ignored if (!use_turn_restrictions) diff --git a/Extractor/RestrictionParser.h b/Extractor/RestrictionParser.h index e428e6166..fcf98dfc5 100644 --- a/Extractor/RestrictionParser.h +++ b/Extractor/RestrictionParser.h @@ -44,16 +44,16 @@ class ScriptingEnvironment; class RestrictionParser { public: - RestrictionParser(ScriptingEnvironment &scripting_environment); + // RestrictionParser(ScriptingEnvironment &scripting_environment); + RestrictionParser(lua_State *lua_state); + mapbox::util::optional TryParse(lua_State *lua_state, osmium::Relation& relation) const; - mapbox::util::optional TryParse(osmium::Relation& relation) const; - - void ReadUseRestrictionsSetting(); - void ReadRestrictionExceptions(); private: - bool ShouldIgnoreRestriction(const std::string &except_tag_string) const; + void ReadUseRestrictionsSetting(lua_State *lua_state); + void ReadRestrictionExceptions(lua_State *lua_state); + bool ShouldIgnoreRestriction(lua_State *lua_state, const std::string &except_tag_string) const; - lua_State *lua_state; + // lua_State *lua_state; std::vector restriction_exceptions; bool use_turn_restrictions; }; From 8e73a4a19df80e696d6dadca04b7f469085a2277 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Tue, 18 Nov 2014 18:53:19 +0100 Subject: [PATCH 71/80] enable relation parsing with libosmium --- Extractor/Extractor.cpp | 10 ++++------ Extractor/RestrictionParser.h | 2 +- 2 files changed, 5 insertions(+), 7 deletions(-) diff --git a/Extractor/Extractor.cpp b/Extractor/Extractor.cpp index 13e82ba29..7cb7f18f5 100644 --- a/Extractor/Extractor.cpp +++ b/Extractor/Extractor.cpp @@ -182,6 +182,9 @@ int Extractor::Run(int argc, char *argv[]) tbb::concurrent_vector> resulting_ways; tbb::concurrent_vector> resulting_restrictions; + // setup restriction parser + RestrictionParser restriction_parser(scripting_environment.getLuaState()); + while (osmium::memory::Buffer buffer = reader.read()) { // create a vector of iterators into the buffer @@ -210,7 +213,6 @@ int Extractor::Run(int argc, char *argv[]) ExtractionNode result_node; ExtractionWay result_way; - // RestrictionParser restriction_parser(scripting_environment); switch (entity->type()) { @@ -222,8 +224,6 @@ int Extractor::Run(int argc, char *argv[]) boost::cref(static_cast(*entity)), boost::ref(result_node)); resulting_nodes.emplace_back(x, result_node); - // extractor_callbacks->ProcessNode(static_cast(*entity), - // result_node); break; case osmium::item_type::way: ++number_of_ways; @@ -233,12 +233,10 @@ int Extractor::Run(int argc, char *argv[]) boost::cref(static_cast(*entity)), boost::ref(result_way)); resulting_ways.emplace_back(x, result_way); - // extractor_callbacks->ProcessWay(static_cast(*entity), result_way); break; case osmium::item_type::relation: ++number_of_relations; - // resulting_restrictions.emplace_back(restriction_parser.TryParse(static_cast(*entity))); - // extractor_callbacks->ProcessRestriction(restriction_parser.TryParse(static_cast(*entity))); + resulting_restrictions.emplace_back(restriction_parser.TryParse(scripting_environment.getLuaState(), static_cast(*entity))); break; default: ++number_of_others; diff --git a/Extractor/RestrictionParser.h b/Extractor/RestrictionParser.h index fcf98dfc5..1cfe2aca5 100644 --- a/Extractor/RestrictionParser.h +++ b/Extractor/RestrictionParser.h @@ -51,7 +51,7 @@ class RestrictionParser private: void ReadUseRestrictionsSetting(lua_State *lua_state); void ReadRestrictionExceptions(lua_State *lua_state); - bool ShouldIgnoreRestriction(lua_State *lua_state, const std::string &except_tag_string) const; + bool ShouldIgnoreRestriction(const std::string &except_tag_string) const; // lua_State *lua_state; std::vector restriction_exceptions; From 3b9c6a6465af0f1cd0f1e7ca9c1d5596e0a9644b Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Tue, 18 Nov 2014 19:03:44 +0100 Subject: [PATCH 72/80] reformat Extractor --- Extractor/Extractor.cpp | 100 ++++++++++++++++++++++------------------ 1 file changed, 54 insertions(+), 46 deletions(-) diff --git a/Extractor/Extractor.cpp b/Extractor/Extractor.cpp index 7cb7f18f5..7f0c2aa83 100644 --- a/Extractor/Extractor.cpp +++ b/Extractor/Extractor.cpp @@ -122,15 +122,19 @@ int Extractor::Run(int argc, char *argv[]) // { // SimpleLogger().Write(logWARNING) << "The recommended number of threads is " // << recommended_num_threads - // << "! This setting may have performance side-effects."; + // << "! This setting may have performance + // side-effects."; // } - auto number_of_threads = std::max(1, - std::min(static_cast(recommended_num_threads), static_cast(extractor_config.requested_num_threads)) ); + auto number_of_threads = + std::max(1, + std::min(static_cast(recommended_num_threads), + static_cast(extractor_config.requested_num_threads))); tbb::task_scheduler_init init(number_of_threads); - SimpleLogger().Write() << "requested_num_threads: " << extractor_config.requested_num_threads; + SimpleLogger().Write() << "requested_num_threads: " + << extractor_config.requested_num_threads; SimpleLogger().Write() << "number_of_threads: " << number_of_threads; // setup scripting environment @@ -180,7 +184,8 @@ int Extractor::Run(int argc, char *argv[]) // initialize vectors holding parsed objects tbb::concurrent_vector> resulting_nodes; tbb::concurrent_vector> resulting_ways; - tbb::concurrent_vector> resulting_restrictions; + tbb::concurrent_vector> + resulting_restrictions; // setup restriction parser RestrictionParser restriction_parser(scripting_environment.getLuaState()); @@ -190,7 +195,7 @@ int Extractor::Run(int argc, char *argv[]) // create a vector of iterators into the buffer std::vector elements; osmium::memory::Buffer::iterator iter = std::begin(buffer); - while(iter != std::end(buffer)) + while (iter != std::end(buffer)) { elements.push_back(iter); iter = std::next(iter); @@ -205,57 +210,60 @@ int Extractor::Run(int argc, char *argv[]) // parse OSM entities in parallel, store in resulting vectors tbb::parallel_for(tbb::blocked_range(0, elements.size()), - [&](const tbb::blocked_range& range) + [&](const tbb::blocked_range &range) + { + for (auto x = range.begin(); x != range.end(); ++x) { - for (auto x = range.begin(); x != range.end(); ++x) - { - auto entity = elements[x]; + auto entity = elements[x]; - ExtractionNode result_node; - ExtractionWay result_way; + ExtractionNode result_node; + ExtractionWay result_way; - switch (entity->type()) - { - case osmium::item_type::node: - ++number_of_nodes; - result_node.Clear(); - luabind::call_function(scripting_environment.getLuaState(), - "node_function", - boost::cref(static_cast(*entity)), - boost::ref(result_node)); - resulting_nodes.emplace_back(x, result_node); - break; - case osmium::item_type::way: - ++number_of_ways; - result_way.Clear(); - luabind::call_function(scripting_environment.getLuaState(), - "way_function", - boost::cref(static_cast(*entity)), - boost::ref(result_way)); - resulting_ways.emplace_back(x, result_way); - break; - case osmium::item_type::relation: - ++number_of_relations; - resulting_restrictions.emplace_back(restriction_parser.TryParse(scripting_environment.getLuaState(), static_cast(*entity))); - break; - default: - ++number_of_others; - break; + switch (entity->type()) + { + case osmium::item_type::node: + ++number_of_nodes; + result_node.Clear(); + luabind::call_function( + scripting_environment.getLuaState(), + "node_function", + boost::cref(static_cast(*entity)), + boost::ref(result_node)); + resulting_nodes.emplace_back(x, result_node); + break; + case osmium::item_type::way: + ++number_of_ways; + result_way.Clear(); + luabind::call_function( + scripting_environment.getLuaState(), + "way_function", + boost::cref(static_cast(*entity)), + boost::ref(result_way)); + resulting_ways.emplace_back(x, result_way); + break; + case osmium::item_type::relation: + ++number_of_relations; + resulting_restrictions.emplace_back( + restriction_parser.TryParse(scripting_environment.getLuaState(), + static_cast(*entity))); + break; + default: + ++number_of_others; + break; + } } - } - } - ); + }); // put parsed objects thru extractor callbacks for (const auto &result : resulting_nodes) { - extractor_callbacks->ProcessNode(static_cast(*(elements[result.first])), - result.second); + extractor_callbacks->ProcessNode( + static_cast(*(elements[result.first])), result.second); } for (const auto &result : resulting_ways) { - extractor_callbacks->ProcessWay(static_cast(*(elements[result.first])), - result.second); + extractor_callbacks->ProcessWay( + static_cast(*(elements[result.first])), result.second); } for (const auto &result : resulting_restrictions) { From 86ee05ee5e25ec98711491cde1e8061eed1fdab6 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Wed, 19 Nov 2014 09:22:31 +0100 Subject: [PATCH 73/80] add missing include --- ThirdParty/osmium/util/double.hpp | 91 +++++++++++++++++++++++++++++++ 1 file changed, 91 insertions(+) create mode 100644 ThirdParty/osmium/util/double.hpp diff --git a/ThirdParty/osmium/util/double.hpp b/ThirdParty/osmium/util/double.hpp new file mode 100644 index 000000000..91f4ac7f1 --- /dev/null +++ b/ThirdParty/osmium/util/double.hpp @@ -0,0 +1,91 @@ +#ifndef OSMIUM_UTIL_DOUBLE_HPP +#define OSMIUM_UTIL_DOUBLE_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include +#include + +namespace osmium { + + namespace util { + + constexpr int max_double_length = 20; // should fit any double + + /** + * Write double to iterator, removing superfluous '0' characters at + * the end. The decimal dot will also be removed if necessary. + * + * @tparam T iterator type + * @param iterator output iterator + * @param value the value that should be written + * @param precision max number of digits after the decimal point (must be <= 17) + */ + template + inline T double2string(T iterator, double value, int precision) { + assert(precision <= 17); + + char buffer[max_double_length]; + +#ifndef _MSC_VER + int len = snprintf(buffer, max_double_length, "%.*f", precision, value); +#else + int len = _snprintf(buffer, max_double_length, "%.*f", precision, value); +#endif + assert(len > 0 && len < max_double_length); + + while (buffer[len-1] == '0') --len; + if (buffer[len-1] == '.') --len; + + return std::copy_n(buffer, len, iterator); + } + + /** + * Write double to string, removing superfluous '0' characters at + * the end. The decimal dot will also be removed if necessary. + * + * @param out string + * @param value the value that should be written + * @param precision max number of digits after the decimal point + */ + inline void double2string(std::string& out, double value, int precision) { + double2string(std::back_inserter(out), value, precision); + } + + } // namespace util + +} // namespace osmium + +#endif // OSMIUM_UTIL_DOUBLE_HPP From 0f4dd8103d75b8bb81a475a4abbdcb0193270797 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Wed, 19 Nov 2014 09:44:02 +0100 Subject: [PATCH 74/80] add cast.hpp from osmium --- ThirdParty/osmium/util/cast.hpp | 72 +++++++++++++++++++++++++++++++++ 1 file changed, 72 insertions(+) create mode 100644 ThirdParty/osmium/util/cast.hpp diff --git a/ThirdParty/osmium/util/cast.hpp b/ThirdParty/osmium/util/cast.hpp new file mode 100644 index 000000000..5feaef05e --- /dev/null +++ b/ThirdParty/osmium/util/cast.hpp @@ -0,0 +1,72 @@ +#ifndef OSMIUM_UTIL_CAST_HPP +#define OSMIUM_UTIL_CAST_HPP + +/* + +This file is part of Osmium (http://osmcode.org/libosmium). + +Copyright 2013,2014 Jochen Topf 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 +#include +#include + +namespace osmium { + + template ::value && std::is_integral::value && std::is_signed::value && std::is_signed::value, int>::type = 0> + inline T static_cast_with_assert(const F value) { + static_assert(sizeof(T) < sizeof(F), "unnecessary static_cast_with_assert when casting into type of equal or larger size"); + assert(value >= std::numeric_limits::min() && value <= std::numeric_limits::max()); + return static_cast(value); + } + + template ::value && std::is_integral::value && std::is_unsigned::value && std::is_signed::value, int>::type = 0> + inline T static_cast_with_assert(const F value) { + static_assert(sizeof(T) <= sizeof(F), "unnecessary static_cast_with_assert when casting into type of larger size"); + assert(value >= 0 && static_cast::type>(value) <= std::numeric_limits::max()); + return static_cast(value); + } + + template ::value && std::is_integral::value && std::is_unsigned::value && std::is_unsigned::value, int>::type = 0> + inline T static_cast_with_assert(const F value) { + static_assert(sizeof(T) < sizeof(F), "unnecessary static_cast_with_assert when casting into type of equal or larger size"); + assert(value <= std::numeric_limits::max()); + return static_cast(value); + } + + template ::value && std::is_integral::value && std::is_signed::value && std::is_unsigned::value, int>::type = 0> + inline T static_cast_with_assert(const F value) { + static_assert(sizeof(T) <= sizeof(F), "unnecessary static_cast_with_assert when casting into type of larger size"); + assert(value <= std::numeric_limits::max()); + return static_cast(value); + } + +} // namespace osmium + +#endif // OSMIUM_UTIL_CAST_HPP From f3e3eda69e425df6d9562e2680e51f49ae7284a3 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Wed, 19 Nov 2014 09:47:23 +0100 Subject: [PATCH 75/80] remove debug output from bike profile --- profiles/bicycle.lua | 1 - 1 file changed, 1 deletion(-) diff --git a/profiles/bicycle.lua b/profiles/bicycle.lua index 3e8abbdf8..3a286639e 100644 --- a/profiles/bicycle.lua +++ b/profiles/bicycle.lua @@ -179,7 +179,6 @@ function way_function (way, result) -- access local access = Access.find_access_tag(way, access_tags_hierachy) if access and access_tag_blacklist[access] then - io.write("skipping " .. access .. "\n") return end From 288c241fb40b9ea06be9142b95fbc6f6a09ac507 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Wed, 19 Nov 2014 09:49:39 +0100 Subject: [PATCH 76/80] move initialization of Lua error callback into scripting environment --- Extractor/Extractor.cpp | 16 ---------------- Extractor/ScriptingEnvironment.cpp | 11 +++++++++++ 2 files changed, 11 insertions(+), 16 deletions(-) diff --git a/Extractor/Extractor.cpp b/Extractor/Extractor.cpp index 7f0c2aa83..9b904d4d5 100644 --- a/Extractor/Extractor.cpp +++ b/Extractor/Extractor.cpp @@ -65,19 +65,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -namespace -{ - -int lua_error_callback(lua_State *L) // This is so I can use my own function as an -// exception handler, pcall_log() -{ - luabind::object error_msg(luabind::from_stack(L, -1)); - std::ostringstream error_stream; - error_stream << error_msg; - throw OSRMException("ERROR occured in profile script:\n" + error_stream.str()); -} -} - int Extractor::Run(int argc, char *argv[]) { ExtractorConfig extractor_config; @@ -178,9 +165,6 @@ int Extractor::Run(int argc, char *argv[]) timestamp_out.write(timestamp.c_str(), timestamp.length()); timestamp_out.close(); - // lua_State *lua_state = scripting_environment.getLuaState(); - luabind::set_pcall_callback(&lua_error_callback); - // initialize vectors holding parsed objects tbb::concurrent_vector> resulting_nodes; tbb::concurrent_vector> resulting_ways; diff --git a/Extractor/ScriptingEnvironment.cpp b/Extractor/ScriptingEnvironment.cpp index b6f56592f..ded2c6938 100644 --- a/Extractor/ScriptingEnvironment.cpp +++ b/Extractor/ScriptingEnvironment.cpp @@ -48,7 +48,17 @@ auto get_value_by_key(T const& object, const char *key) -> decltype(object.get_v { return object.get_value_by_key(key, ""); } + +int lua_error_callback(lua_State *L) // This is so I can use my own function as an +// exception handler, pcall_log() +{ + luabind::object error_msg(luabind::from_stack(L, -1)); + std::ostringstream error_stream; + error_stream << error_msg; + throw OSRMException("ERROR occured in profile script:\n" + error_stream.str()); } +} + ScriptingEnvironment::ScriptingEnvironment(const char *file_name) : file_name(file_name) @@ -129,6 +139,7 @@ lua_State *ScriptingEnvironment::getLuaState() ref = state; initLuaState(ref.get()); } + luabind::set_pcall_callback(&lua_error_callback); return ref.get(); } From 4fce0dadcfdb5467adddc84b92e0b48b53970c4a Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Wed, 19 Nov 2014 09:58:41 +0100 Subject: [PATCH 77/80] remove further debug output from profiles --- profiles/bicycle.lua | 2 -- profiles/testbot.lua | 1 - 2 files changed, 3 deletions(-) diff --git a/profiles/bicycle.lua b/profiles/bicycle.lua index 3a286639e..713c6b737 100644 --- a/profiles/bicycle.lua +++ b/profiles/bicycle.lua @@ -138,7 +138,6 @@ function node_function (node, result) -- parse access and barrier tags if access and access ~= "" then if access_tag_blacklist[access] then - io.write("node access: " .. access .. "\n") result.barrier = true else result.barrier = false @@ -147,7 +146,6 @@ function node_function (node, result) if barrier_whitelist[barrier] then result.barrier = false else - io.write("barrier access: " .. barrier .. "\n") result.barrier = true end end diff --git a/profiles/testbot.lua b/profiles/testbot.lua index dcf0130c2..7bd141635 100644 --- a/profiles/testbot.lua +++ b/profiles/testbot.lua @@ -49,7 +49,6 @@ function node_function (node, result) local traffic_signal = node:get_value_by_key("highway") if traffic_signal and traffic_signal == "traffic_signals" then - io.write("traffic_signal\n") result.traffic_lights = true; -- TODO: a way to set the penalty value end From 2da427134b73c6375ce33a3b3a16d043fc9af350 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Wed, 19 Nov 2014 10:12:08 +0100 Subject: [PATCH 78/80] use push_back to insert into tbb::concurrent_vector as emplace_back is not generally available --- Extractor/Extractor.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Extractor/Extractor.cpp b/Extractor/Extractor.cpp index 9b904d4d5..8abd59313 100644 --- a/Extractor/Extractor.cpp +++ b/Extractor/Extractor.cpp @@ -213,7 +213,7 @@ int Extractor::Run(int argc, char *argv[]) "node_function", boost::cref(static_cast(*entity)), boost::ref(result_node)); - resulting_nodes.emplace_back(x, result_node); + resulting_nodes.push_back(std::make_pair(x, result_node)); break; case osmium::item_type::way: ++number_of_ways; @@ -223,11 +223,11 @@ int Extractor::Run(int argc, char *argv[]) "way_function", boost::cref(static_cast(*entity)), boost::ref(result_way)); - resulting_ways.emplace_back(x, result_way); + resulting_ways.push_back(std::make_pair(x, result_way)); break; case osmium::item_type::relation: ++number_of_relations; - resulting_restrictions.emplace_back( + resulting_restrictions.push_back( restriction_parser.TryParse(scripting_environment.getLuaState(), static_cast(*entity))); break; From 0361e0204a2bba5b425f8eeb5ea840576a0fb42b Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Wed, 19 Nov 2014 10:53:28 +0100 Subject: [PATCH 79/80] rename Clear() method to clear() --- Extractor/ExtractionNode.h | 2 +- Extractor/ExtractionWay.h | 4 ++-- Extractor/Extractor.cpp | 37 ++++++++++++------------------------- 3 files changed, 15 insertions(+), 28 deletions(-) diff --git a/Extractor/ExtractionNode.h b/Extractor/ExtractionNode.h index b53321ed5..799455102 100644 --- a/Extractor/ExtractionNode.h +++ b/Extractor/ExtractionNode.h @@ -31,7 +31,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. struct ExtractionNode { ExtractionNode() : traffic_lights(false), barrier(false) { } - void Clear() + void clear() { traffic_lights = barrier = false; } diff --git a/Extractor/ExtractionWay.h b/Extractor/ExtractionWay.h index 740c4beaf..2e64ba6e2 100644 --- a/Extractor/ExtractionWay.h +++ b/Extractor/ExtractionWay.h @@ -36,9 +36,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. struct ExtractionWay { - ExtractionWay() { Clear(); } + ExtractionWay() { clear(); } - void Clear() + void clear() { forward_speed = -1; backward_speed = -1; diff --git a/Extractor/Extractor.cpp b/Extractor/Extractor.cpp index 8abd59313..2c23edfdc 100644 --- a/Extractor/Extractor.cpp +++ b/Extractor/Extractor.cpp @@ -105,13 +105,6 @@ int Extractor::Run(int argc, char *argv[]) SimpleLogger().Write() << "Input file: " << extractor_config.input_path.filename().string(); SimpleLogger().Write() << "Profile: " << extractor_config.profile_path.filename().string(); SimpleLogger().Write() << "Threads: " << extractor_config.requested_num_threads; - // if (recommended_num_threads != extractor_config.requested_num_threads) - // { - // SimpleLogger().Write(logWARNING) << "The recommended number of threads is " - // << recommended_num_threads - // << "! This setting may have performance - // side-effects."; - // } auto number_of_threads = std::max(1, @@ -120,22 +113,18 @@ int Extractor::Run(int argc, char *argv[]) tbb::task_scheduler_init init(number_of_threads); - SimpleLogger().Write() << "requested_num_threads: " - << extractor_config.requested_num_threads; - SimpleLogger().Write() << "number_of_threads: " << number_of_threads; - // setup scripting environment ScriptingEnvironment scripting_environment(extractor_config.profile_path.string().c_str()); std::unordered_map string_map; - ExtractionContainers extraction_containers; - string_map[""] = 0; + + ExtractionContainers extraction_containers; auto extractor_callbacks = osrm::make_unique(extraction_containers, string_map); - osmium::io::File infile(extractor_config.input_path.string()); - osmium::io::Reader reader(infile); + osmium::io::File input_file(extractor_config.input_path.string()); + osmium::io::Reader reader(input_file); osmium::io::Header header = reader.header(); unsigned number_of_nodes = 0; @@ -177,11 +166,11 @@ int Extractor::Run(int argc, char *argv[]) while (osmium::memory::Buffer buffer = reader.read()) { // create a vector of iterators into the buffer - std::vector elements; + std::vector osm_elements; osmium::memory::Buffer::iterator iter = std::begin(buffer); while (iter != std::end(buffer)) { - elements.push_back(iter); + osm_elements.push_back(iter); iter = std::next(iter); } @@ -190,15 +179,13 @@ int Extractor::Run(int argc, char *argv[]) resulting_ways.clear(); resulting_restrictions.clear(); - // SimpleLogger().Write(logDEBUG) << "elements count: " << elements.size(); - // parse OSM entities in parallel, store in resulting vectors - tbb::parallel_for(tbb::blocked_range(0, elements.size()), + tbb::parallel_for(tbb::blocked_range(0, osm_elements.size()), [&](const tbb::blocked_range &range) { for (auto x = range.begin(); x != range.end(); ++x) { - auto entity = elements[x]; + auto entity = osm_elements[x]; ExtractionNode result_node; ExtractionWay result_way; @@ -207,7 +194,7 @@ int Extractor::Run(int argc, char *argv[]) { case osmium::item_type::node: ++number_of_nodes; - result_node.Clear(); + result_node.clear(); luabind::call_function( scripting_environment.getLuaState(), "node_function", @@ -217,7 +204,7 @@ int Extractor::Run(int argc, char *argv[]) break; case osmium::item_type::way: ++number_of_ways; - result_way.Clear(); + result_way.clear(); luabind::call_function( scripting_environment.getLuaState(), "way_function", @@ -242,12 +229,12 @@ int Extractor::Run(int argc, char *argv[]) for (const auto &result : resulting_nodes) { extractor_callbacks->ProcessNode( - static_cast(*(elements[result.first])), result.second); + static_cast(*(osm_elements[result.first])), result.second); } for (const auto &result : resulting_ways) { extractor_callbacks->ProcessWay( - static_cast(*(elements[result.first])), result.second); + static_cast(*(osm_elements[result.first])), result.second); } for (const auto &result : resulting_restrictions) { From 60c268ddd6604ec69c067afd99ef5ddc35d8f328 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Wed, 19 Nov 2014 11:02:38 +0100 Subject: [PATCH 80/80] reorder some of the code --- Extractor/Extractor.cpp | 14 ++++---------- 1 file changed, 4 insertions(+), 10 deletions(-) diff --git a/Extractor/Extractor.cpp b/Extractor/Extractor.cpp index 2c23edfdc..7623ce100 100644 --- a/Extractor/Extractor.cpp +++ b/Extractor/Extractor.cpp @@ -101,17 +101,12 @@ int Extractor::Run(int argc, char *argv[]) } const unsigned recommended_num_threads = tbb::task_scheduler_init::default_num_threads(); + const auto number_of_threads = std::min(recommended_num_threads, extractor_config.requested_num_threads); + tbb::task_scheduler_init init(number_of_threads); SimpleLogger().Write() << "Input file: " << extractor_config.input_path.filename().string(); SimpleLogger().Write() << "Profile: " << extractor_config.profile_path.filename().string(); - SimpleLogger().Write() << "Threads: " << extractor_config.requested_num_threads; - - auto number_of_threads = - std::max(1, - std::min(static_cast(recommended_num_threads), - static_cast(extractor_config.requested_num_threads))); - - tbb::task_scheduler_init init(number_of_threads); + SimpleLogger().Write() << "Threads: " << number_of_threads; // setup scripting environment ScriptingEnvironment scripting_environment(extractor_config.profile_path.string().c_str()); @@ -245,7 +240,7 @@ int Extractor::Run(int argc, char *argv[]) SimpleLogger().Write() << "Parsing finished after " << TIMER_SEC(parsing) << " seconds"; SimpleLogger().Write() << "Raw input contains " << number_of_nodes << " nodes, " << number_of_ways << " ways, and " << number_of_relations - << " relations"; + << " relations, and " << number_of_others << " unknown entities"; extractor_callbacks.reset(); @@ -257,7 +252,6 @@ int Extractor::Run(int argc, char *argv[]) extraction_containers.PrepareData(extractor_config.output_file_name, extractor_config.restriction_file_name); - TIMER_STOP(extracting); SimpleLogger().Write() << "extraction finished after " << TIMER_SEC(extracting) << "s"; SimpleLogger().Write() << "To prepare the data for routing, run: "