babbda98a6
40c4a48 Release v2.10.0 6addb2e Search for protozero also in the place where libosmium was found. 9c0d4bb Consistently use lhs and rhs as parameter names in operators etc. 6179759 Update change log. 894eb7d Explicitly use size_t to get no narrowing conversions. e549e73 Fix CMake config for index_lookup. ccf0bc2 Fix bug where some compilers deduce the wrong type. fc3507d Cleaned and documented index example and renamed to osmium_index_lookup. d3c3036 Rename serdump example to dump_internal and document it. 0e9822e Also forward set_uid_from_signed() function. 29ef95c Rename build_taglist function because it was to similar to build_tag_list. c088dd0 Move static constant out of class so clang will compile it. 606cdc4 Fix CMake build script: Path for finding libosmium. 65f91fe Removed unused typedef. 07174f5 Use condition_variable to tell producer when thread queue is not full. b35e957 Some code cleanup in XML parser. c703dff Fix problem with MemberMeta. 1ccbbef Refactoring CompressionFactory. 6561bd6 Use our own exception type for map factory errors. 56e31fa Throw not_found error directly instead of using helper function. 28230c3 Test empty value for node location store, reorganize tests. 2ba316c Reorganize and fix projection tests. f949485 Don't run quite as many tests with projections because they are slow. 1bad16d Add information about build environment to benchmark output. 99617bb Change proj_geojson benchmark into mercator benchmark. 553b946 Allow optional parameters on Reader in any order. dcc3d8f Factor out some common code. 004d8cd Fix forwarding constructor. 9702978 Fix metadata check. 6cfb6c4 Faster implementation of decode_dense_nodes without reading metdata. 4ba4638 Add additional read_metadata parameter to other Reader constructors. d005937 Optionally ignore metadata when reading file. 63961da Mark all CRC32 update functions as noexcept. cc4ca75 Refactor set_user() function to speed it up. 38d19dc Update comments with file sizes. OSM has grown... f7d0824 Add new benchmark that shows performance when main thread is busy. 25070dc Use const ref params. 88e8d96 Mark add_user() as deprecated. f58d9db Refactor some low-level collection code to clean up code. 4680def Add example showing how to create OSM data out of thin air. d42fd50 Add an example showing how tags in OSM files can be changed. 49bf5bc Add additional constructors to Builders taking a reference to parent. 7b91d63 Change Builder::add_item() to take a reference instead of pointer. 2957e48 Some cleanup of examples. d0b458d Calculate size of object at compile time. 3fbb6e7 Use explicit cast. 1851f3d Remove a test that depends on math details. f6a0802 Various cleanups of example programs. ba4921f Rename add_user() to set_user(). d7637c9 Various cleanups related to builders. 07827bc Fix add_user(). 9a5b395 Also refactor OSMObjectBuilder like ChangesetBuilder before. b1f423c Use call chaining on the builder. e49473d Get rid of ObjectBuilder class. 67d70b9 Refactor ChangesetBuilder::add_user(). 8199c33 Make ChangesetBuilder derive directly from Builder. 61d1b67 Simplify some code. d38467a Change derivation hierarchy of some builder classes. b52f8af Refactor Builder code. d012bfa Refactored some code setting attributes on objects using builder instead. 6a05f60 Also forward set_removed function from builders. 8d63b7d Return *this from Builder setter functions and test it. 72a1266 Update catch.hpp to newest version. 3424a74 Check GEOS version is <= 3.5. aee9f9d Cleanup test code. aef198c Improved asserts in Buffer. a98b9bf Code cleanup in tests. a150466 Use GDAL/OGR instead of GEOS to test our WKB implementation. b04a525 Refactor test. 39aa932 Refactored test_factory_with_projection so it works without GEOS. 648f43a Remove unused dependency on geos from tile test. f1748ae Add setters to Builder classes forwarding to underlying objects. 8166879 In debug mode check that Builders are correctly called and destructed. 1c4257e Call commit() on buffer only after all builders are destructed. 2618636 Add functions to check availability of relation members. b45a4d9 Mark RelationMember::set_ref() as deprecated. 7886771 Move "basic" and "buffer" tests to "osm" and "memory", respectively. b664685 Use functions instead of macros in location test for faster compile. b4929ac Add more tests for number parser. 02662a7 Merge pull request #171 from lonvia/fix-long-exponentials 5344a6c fix parsing of numbers in e-notiation with many post-comma digits 3aeaff3 Add some typedefs to NodeRefList and memory::Collection. e750665 Add iterators to IdSetSmall and add docs and tests to IdSet classes. 50ecb2a Add more features to IdSetDense, including unset and iterator. e3dec78 Make IdSet virtual base class with two implementations. 8ea0153 Use C array instead of std::array in IdSet and clear explicitly. 3ba9905 Deprecate osmium::index::BoolVector in favour of new IdSet. 453d1ca Add osmium::index::IdSet. c78254e Add function to (temporarily) disable the progress bar. 4d88a9f Better document osmium::io::Header class. 320e3af Look for protozero includes in CMake config. 838d25e Allow optional checking for libosmium version number in CMake config. 6ce60c1 Fix entity_bits static_assert() tests. f054731 Update change log. 77ac4c2 Make sleep duration for full queues much smaller. 7e39c01 Make some entity_bits functions constexpr. 69ea72f Fix ~ operator on entity_bits and more tests for entity bits. dafe4cf Update embedded Catch unit test header to version 1.5.7. a41c832 Fixed parsing of location coordinates starting with decimal dot. 6523bae README cosmetics. 229acac Add tests for some examples. f1e753d Merge pull request #163 from sebastic/executable-not-elf-or-script ccea2d5 Remove executable bit from .cpp files. af77fb4 Changelog formatting fixes. git-subtree-dir: third_party/libosmium git-subtree-split: 40c4a48f88d25edace6f0b9e079c306308c7760b
923 lines
40 KiB
C++
923 lines
40 KiB
C++
#ifndef OSMIUM_BUILDER_ATTR_HPP
|
|
#define OSMIUM_BUILDER_ATTR_HPP
|
|
|
|
/*
|
|
|
|
This file is part of Osmium (http://osmcode.org/libosmium).
|
|
|
|
Copyright 2013-2016 Jochen Topf <jochen@topf.org> and others (see README).
|
|
|
|
Boost Software License - Version 1.0 - August 17th, 2003
|
|
|
|
Permission is hereby granted, free of charge, to any person or organization
|
|
obtaining a copy of the software and accompanying documentation covered by
|
|
this license (the "Software") to use, reproduce, display, distribute,
|
|
execute, and transmit the Software, and to prepare derivative works of the
|
|
Software, and to permit third-parties to whom the Software is furnished to
|
|
do so, all subject to the following:
|
|
|
|
The copyright notices in the Software and this entire statement, including
|
|
the above license grant, this restriction and the following disclaimer,
|
|
must be included in all copies of the Software, in whole or in part, and
|
|
all derivative works of the Software, unless such copies or derivative
|
|
works are solely in the form of machine-executable object code generated by
|
|
a source language processor.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
|
|
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
|
|
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
|
|
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
DEALINGS IN THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
#include <ctime>
|
|
#include <initializer_list>
|
|
#include <iterator>
|
|
#include <string>
|
|
#include <tuple>
|
|
#include <type_traits>
|
|
#include <utility>
|
|
|
|
#include <osmium/builder/builder.hpp>
|
|
#include <osmium/builder/osm_object_builder.hpp>
|
|
#include <osmium/memory/buffer.hpp>
|
|
#include <osmium/osm/changeset.hpp>
|
|
#include <osmium/osm/item_type.hpp>
|
|
#include <osmium/osm/location.hpp>
|
|
#include <osmium/osm/node.hpp>
|
|
#include <osmium/osm/node_ref.hpp>
|
|
#include <osmium/osm/object.hpp>
|
|
#include <osmium/osm/relation.hpp>
|
|
#include <osmium/osm/timestamp.hpp>
|
|
#include <osmium/osm/types.hpp>
|
|
|
|
namespace osmium {
|
|
|
|
namespace builder {
|
|
|
|
namespace detail {
|
|
|
|
#ifdef _MSC_VER
|
|
// workaround for bug in MSVC
|
|
|
|
template <typename THandler, typename... TTypes>
|
|
struct is_handled_by;
|
|
|
|
template <typename THandler>
|
|
struct is_handled_by<THandler> {
|
|
static constexpr bool value = false;
|
|
};
|
|
|
|
template <typename THandler, typename T, typename... TRest>
|
|
struct is_handled_by<THandler, T, TRest...> {
|
|
static constexpr bool value = std::is_base_of<typename T::handler, THandler>::value ||
|
|
is_handled_by<THandler, TRest...>::value;
|
|
};
|
|
|
|
template <typename THandler, typename... TTypes>
|
|
struct are_all_handled_by;
|
|
|
|
template <typename THandler, typename T>
|
|
struct are_all_handled_by<THandler, T> {
|
|
static constexpr bool value = std::is_base_of<typename T::handler, THandler>::value;
|
|
};
|
|
|
|
template <typename THandler, typename T, typename... TRest>
|
|
struct are_all_handled_by<THandler, T, TRest...> {
|
|
static constexpr bool value = std::is_base_of<typename T::handler, THandler>::value &&
|
|
are_all_handled_by<THandler, TRest...>::value;
|
|
};
|
|
#else
|
|
// True if Predicate matches for none of the types Ts
|
|
template <template<typename> class Predicate, typename... Ts>
|
|
struct static_none_of : std::is_same<std::tuple<std::false_type, typename Predicate<Ts>::type...>,
|
|
std::tuple<typename Predicate<Ts>::type..., std::false_type>>
|
|
{};
|
|
|
|
// True if Predicate matches for all of the types Ts
|
|
template <template<typename> class Predicate, typename... Ts>
|
|
struct static_all_of : std::is_same<std::tuple<std::true_type, typename Predicate<Ts>::type...>,
|
|
std::tuple<typename Predicate<Ts>::type..., std::true_type>>
|
|
{};
|
|
|
|
// True if THandler is derived from the handler for at least one of the types in TTypes
|
|
template <typename THandler, typename... TTypes>
|
|
struct is_handled_by {
|
|
template <typename T>
|
|
using HasHandler = std::is_base_of<typename T::handler, THandler>;
|
|
|
|
static constexpr bool value = !static_none_of<HasHandler, TTypes...>::value;
|
|
};
|
|
|
|
// True if THandler is derived from the handlers of all the types in TTypes
|
|
template <typename THandler, typename... TTypes>
|
|
struct are_all_handled_by {
|
|
template <typename T>
|
|
using HasHandler = std::is_base_of<typename T::handler, THandler>;
|
|
|
|
static constexpr bool value = static_all_of<HasHandler, TTypes...>::value;
|
|
};
|
|
#endif
|
|
|
|
|
|
// Wraps any type, so that we can derive from it
|
|
template <typename TType>
|
|
struct type_wrapper {
|
|
|
|
using type = TType;
|
|
|
|
TType value;
|
|
|
|
constexpr explicit type_wrapper(const TType& v) :
|
|
value(v) {
|
|
}
|
|
|
|
}; // struct type_wrapper
|
|
|
|
// Small wrapper for begin/end iterator
|
|
template <typename TType>
|
|
struct iterator_wrapper {
|
|
|
|
using type = TType;
|
|
|
|
TType first;
|
|
TType last;
|
|
|
|
constexpr iterator_wrapper(TType begin, TType end) :
|
|
first(begin),
|
|
last(end) {}
|
|
|
|
constexpr TType begin() const {
|
|
return first;
|
|
}
|
|
|
|
constexpr TType end() const {
|
|
return last;
|
|
}
|
|
|
|
}; // struct iterator_wrapper
|
|
|
|
|
|
struct entity_handler {};
|
|
struct object_handler;
|
|
struct node_handler;
|
|
struct tags_handler;
|
|
struct nodes_handler;
|
|
struct members_handler;
|
|
struct changeset_handler;
|
|
struct discussion_handler;
|
|
struct ring_handler;
|
|
|
|
} // namespace detail
|
|
|
|
#define OSMIUM_ATTRIBUTE(_handler, _name, _type) \
|
|
struct _name : public osmium::builder::detail::type_wrapper<_type> { \
|
|
using handler = osmium::builder::detail::_handler;
|
|
|
|
#define OSMIUM_ATTRIBUTE_WITH_CONSTRUCTOR(_handler, _name, _type) \
|
|
OSMIUM_ATTRIBUTE(_handler, _name, _type) \
|
|
constexpr explicit _name(std::add_const<_type>::type& value) : \
|
|
type_wrapper(value) {} \
|
|
}
|
|
|
|
#define OSMIUM_ATTRIBUTE_ITER(_handler, _name) \
|
|
template <typename TIterator> \
|
|
struct _name : public osmium::builder::detail::iterator_wrapper<TIterator> { \
|
|
using handler = osmium::builder::detail::_handler; \
|
|
constexpr _name(TIterator first, TIterator last) : \
|
|
osmium::builder::detail::iterator_wrapper<TIterator>(first, last) {} \
|
|
}
|
|
|
|
namespace attr {
|
|
|
|
OSMIUM_ATTRIBUTE_WITH_CONSTRUCTOR(object_handler, _id, osmium::object_id_type);
|
|
OSMIUM_ATTRIBUTE_WITH_CONSTRUCTOR(object_handler, _version, osmium::object_version_type);
|
|
OSMIUM_ATTRIBUTE_WITH_CONSTRUCTOR(entity_handler, _uid, osmium::user_id_type);
|
|
OSMIUM_ATTRIBUTE_WITH_CONSTRUCTOR(entity_handler, _cid, osmium::changeset_id_type);
|
|
|
|
OSMIUM_ATTRIBUTE(object_handler, _deleted, bool)
|
|
constexpr explicit _deleted(bool value = true) noexcept :
|
|
type_wrapper(value) {}
|
|
};
|
|
|
|
OSMIUM_ATTRIBUTE(object_handler, _visible, bool)
|
|
constexpr explicit _visible(bool value = true) noexcept :
|
|
type_wrapper(value) {}
|
|
};
|
|
|
|
OSMIUM_ATTRIBUTE(object_handler, _timestamp, osmium::Timestamp)
|
|
constexpr explicit _timestamp(const osmium::Timestamp& value) noexcept :
|
|
type_wrapper(value) {}
|
|
constexpr explicit _timestamp(time_t value) noexcept :
|
|
type_wrapper(osmium::Timestamp{value}) {}
|
|
constexpr explicit _timestamp(uint32_t value) noexcept :
|
|
type_wrapper(osmium::Timestamp{value}) {}
|
|
explicit _timestamp(const char* value) :
|
|
type_wrapper(osmium::Timestamp{value}) {}
|
|
explicit _timestamp(const std::string& value) :
|
|
type_wrapper(osmium::Timestamp{value}) {}
|
|
};
|
|
|
|
OSMIUM_ATTRIBUTE(node_handler, _location, osmium::Location)
|
|
constexpr explicit _location(const osmium::Location& value) noexcept :
|
|
type_wrapper(value) {}
|
|
explicit _location(double lat, double lon) :
|
|
type_wrapper(osmium::Location{lat, lon}) {}
|
|
};
|
|
|
|
OSMIUM_ATTRIBUTE(entity_handler, _user, const char*)
|
|
constexpr explicit _user(const char* val) noexcept :
|
|
type_wrapper(val) {}
|
|
explicit _user(const std::string& val) noexcept :
|
|
type_wrapper(val.c_str()) {}
|
|
};
|
|
|
|
using pair_of_cstrings = std::pair<const char* const, const char* const>;
|
|
using pair_of_strings = std::pair<const std::string&, const std::string&>;
|
|
|
|
class member_type {
|
|
|
|
osmium::item_type m_type;
|
|
osmium::object_id_type m_ref;
|
|
const char* m_role;
|
|
|
|
public:
|
|
|
|
constexpr member_type(osmium::item_type type, osmium::object_id_type ref, const char* role = "") noexcept :
|
|
m_type(type),
|
|
m_ref(ref),
|
|
m_role(role) {
|
|
}
|
|
|
|
constexpr osmium::item_type type() const noexcept {
|
|
return m_type;
|
|
}
|
|
|
|
constexpr osmium::object_id_type ref() const noexcept {
|
|
return m_ref;
|
|
}
|
|
|
|
constexpr const char* role() const noexcept {
|
|
return m_role;
|
|
}
|
|
|
|
}; // class member_type
|
|
|
|
class member_type_string {
|
|
|
|
osmium::item_type m_type;
|
|
osmium::object_id_type m_ref;
|
|
std::string m_role;
|
|
|
|
public:
|
|
|
|
member_type_string(osmium::item_type type, osmium::object_id_type ref, std::string&& role) :
|
|
m_type(type),
|
|
m_ref(ref),
|
|
m_role(std::move(role)) {
|
|
}
|
|
|
|
osmium::item_type type() const noexcept {
|
|
return m_type;
|
|
}
|
|
|
|
osmium::object_id_type ref() const noexcept {
|
|
return m_ref;
|
|
}
|
|
|
|
const char* role() const noexcept {
|
|
return m_role.c_str();
|
|
}
|
|
|
|
}; // class member_type_string
|
|
|
|
class comment_type {
|
|
|
|
osmium::Timestamp m_date;
|
|
osmium::user_id_type m_uid;
|
|
const char* m_user;
|
|
const char* m_text;
|
|
|
|
public:
|
|
|
|
constexpr comment_type(osmium::Timestamp date, osmium::user_id_type uid, const char* user, const char* text) noexcept :
|
|
m_date(date),
|
|
m_uid(uid),
|
|
m_user(user),
|
|
m_text(text) {
|
|
}
|
|
|
|
constexpr osmium::Timestamp date() const noexcept {
|
|
return m_date;
|
|
}
|
|
|
|
constexpr osmium::user_id_type uid() const noexcept {
|
|
return m_uid;
|
|
}
|
|
|
|
constexpr const char* user() const noexcept {
|
|
return m_user;
|
|
}
|
|
|
|
constexpr const char* text() const noexcept {
|
|
return m_text;
|
|
}
|
|
|
|
}; // class comment_type
|
|
|
|
namespace detail {
|
|
|
|
OSMIUM_ATTRIBUTE_ITER(tags_handler, tags_from_iterator_pair);
|
|
|
|
OSMIUM_ATTRIBUTE_ITER(nodes_handler, nodes_from_iterator_pair);
|
|
|
|
OSMIUM_ATTRIBUTE_ITER(members_handler, members_from_iterator_pair);
|
|
|
|
OSMIUM_ATTRIBUTE_ITER(discussion_handler, comments_from_iterator_pair);
|
|
|
|
OSMIUM_ATTRIBUTE_ITER(ring_handler, outer_ring_from_iterator_pair);
|
|
OSMIUM_ATTRIBUTE_ITER(ring_handler, inner_ring_from_iterator_pair);
|
|
|
|
} // namespace detail
|
|
|
|
OSMIUM_ATTRIBUTE(tags_handler, _tag, pair_of_cstrings)
|
|
explicit _tag(const pair_of_cstrings& value) noexcept :
|
|
type_wrapper(value) {}
|
|
explicit _tag(const std::pair<const char* const, const char*>& value) :
|
|
type_wrapper(pair_of_cstrings{value.first, value.second}) {}
|
|
explicit _tag(const std::pair<const char*, const char* const>& value) :
|
|
type_wrapper(pair_of_cstrings{value.first, value.second}) {}
|
|
explicit _tag(const std::pair<const char*, const char*>& value) :
|
|
type_wrapper(pair_of_cstrings{value.first, value.second}) {}
|
|
explicit _tag(const pair_of_strings& value) :
|
|
type_wrapper(std::make_pair(value.first.c_str(), value.second.c_str())) {}
|
|
explicit _tag(const char* key, const char* val) :
|
|
type_wrapper(std::make_pair(key, val)) {}
|
|
explicit _tag(const std::string& key, const std::string& val) :
|
|
type_wrapper(std::make_pair(key.c_str(), val.c_str())) {}
|
|
};
|
|
|
|
template <typename TTagIterator>
|
|
inline constexpr detail::tags_from_iterator_pair<TTagIterator> _tags(TTagIterator first, TTagIterator last) {
|
|
return detail::tags_from_iterator_pair<TTagIterator>(first, last);
|
|
}
|
|
|
|
template <typename TContainer>
|
|
inline detail::tags_from_iterator_pair<typename TContainer::const_iterator> _tags(const TContainer& container) {
|
|
return detail::tags_from_iterator_pair<typename TContainer::const_iterator>(std::begin(container), std::end(container));
|
|
}
|
|
|
|
using tag_ilist = std::initializer_list<std::pair<const char*, const char*>>;
|
|
inline detail::tags_from_iterator_pair<tag_ilist::const_iterator> _tags(const tag_ilist& container) {
|
|
return detail::tags_from_iterator_pair<tag_ilist::const_iterator>(std::begin(container), std::end(container));
|
|
}
|
|
|
|
|
|
|
|
OSMIUM_ATTRIBUTE(nodes_handler, _node, osmium::NodeRef)
|
|
constexpr explicit _node(osmium::object_id_type value) noexcept :
|
|
type_wrapper(NodeRef{value}) {}
|
|
constexpr explicit _node(const NodeRef& value) noexcept :
|
|
type_wrapper(value) {}
|
|
};
|
|
|
|
template <typename TIdIterator>
|
|
inline constexpr detail::nodes_from_iterator_pair<TIdIterator> _nodes(TIdIterator first, TIdIterator last) {
|
|
return detail::nodes_from_iterator_pair<TIdIterator>(first, last);
|
|
}
|
|
|
|
template <typename TContainer>
|
|
inline detail::nodes_from_iterator_pair<typename TContainer::const_iterator> _nodes(const TContainer& container) {
|
|
return detail::nodes_from_iterator_pair<typename TContainer::const_iterator>(std::begin(container), std::end(container));
|
|
}
|
|
|
|
using object_id_ilist = std::initializer_list<osmium::object_id_type>;
|
|
inline detail::nodes_from_iterator_pair<object_id_ilist::const_iterator> _nodes(const object_id_ilist& container) {
|
|
return detail::nodes_from_iterator_pair<object_id_ilist::const_iterator>(std::begin(container), std::end(container));
|
|
}
|
|
|
|
using node_ref_ilist = std::initializer_list<osmium::NodeRef>;
|
|
inline detail::nodes_from_iterator_pair<node_ref_ilist::const_iterator> _nodes(const node_ref_ilist& container) {
|
|
return detail::nodes_from_iterator_pair<node_ref_ilist::const_iterator>(std::begin(container), std::end(container));
|
|
}
|
|
|
|
|
|
OSMIUM_ATTRIBUTE(members_handler, _member, member_type)
|
|
constexpr explicit _member(const member_type& value) noexcept :
|
|
type_wrapper(value) {}
|
|
constexpr explicit _member(osmium::item_type type, osmium::object_id_type id) noexcept :
|
|
type_wrapper({type, id}) {}
|
|
constexpr explicit _member(osmium::item_type type, osmium::object_id_type id, const char* role) noexcept :
|
|
type_wrapper({type, id, role}) {}
|
|
explicit _member(osmium::item_type type, osmium::object_id_type id, const std::string& role) noexcept :
|
|
type_wrapper({type, id, role.c_str()}) {}
|
|
explicit _member(const osmium::RelationMember& member) noexcept :
|
|
type_wrapper({member.type(), member.ref(), member.role()}) {}
|
|
};
|
|
|
|
template <typename TMemberIterator>
|
|
inline constexpr detail::members_from_iterator_pair<TMemberIterator> _members(TMemberIterator first, TMemberIterator last) {
|
|
return detail::members_from_iterator_pair<TMemberIterator>(first, last);
|
|
}
|
|
|
|
template <typename TContainer>
|
|
inline detail::members_from_iterator_pair<typename TContainer::const_iterator> _members(const TContainer& container) {
|
|
return detail::members_from_iterator_pair<typename TContainer::const_iterator>(std::begin(container), std::end(container));
|
|
}
|
|
|
|
using member_ilist = std::initializer_list<member_type>;
|
|
inline detail::members_from_iterator_pair<member_ilist::const_iterator> _members(const member_ilist& container) {
|
|
return detail::members_from_iterator_pair<member_ilist::const_iterator>(std::begin(container), std::end(container));
|
|
}
|
|
|
|
|
|
OSMIUM_ATTRIBUTE_WITH_CONSTRUCTOR(changeset_handler, _num_changes, osmium::num_changes_type);
|
|
OSMIUM_ATTRIBUTE_WITH_CONSTRUCTOR(changeset_handler, _num_comments, osmium::num_comments_type);
|
|
OSMIUM_ATTRIBUTE_WITH_CONSTRUCTOR(changeset_handler, _created_at, osmium::Timestamp);
|
|
OSMIUM_ATTRIBUTE_WITH_CONSTRUCTOR(changeset_handler, _closed_at, osmium::Timestamp);
|
|
|
|
OSMIUM_ATTRIBUTE(discussion_handler, _comment, comment_type)
|
|
constexpr explicit _comment(const comment_type& value) noexcept :
|
|
type_wrapper(value) {}
|
|
explicit _comment(const osmium::ChangesetComment& comment) noexcept :
|
|
type_wrapper({comment.date(), comment.uid(), comment.user(), comment.text()}) {}
|
|
};
|
|
|
|
template <typename TCommentIterator>
|
|
inline constexpr detail::comments_from_iterator_pair<TCommentIterator> _comments(TCommentIterator first, TCommentIterator last) {
|
|
return detail::comments_from_iterator_pair<TCommentIterator>(first, last);
|
|
}
|
|
|
|
template <typename TContainer>
|
|
inline detail::comments_from_iterator_pair<typename TContainer::const_iterator> _comments(const TContainer& container) {
|
|
return detail::comments_from_iterator_pair<typename TContainer::const_iterator>(std::begin(container), std::end(container));
|
|
}
|
|
|
|
using comment_ilist = std::initializer_list<comment_type>;
|
|
inline detail::comments_from_iterator_pair<comment_ilist::const_iterator> _comments(const comment_ilist& container) {
|
|
return detail::comments_from_iterator_pair<comment_ilist::const_iterator>(std::begin(container), std::end(container));
|
|
}
|
|
|
|
|
|
template <typename TIdIterator>
|
|
inline constexpr detail::outer_ring_from_iterator_pair<TIdIterator> _outer_ring(TIdIterator first, TIdIterator last) {
|
|
return detail::outer_ring_from_iterator_pair<TIdIterator>(first, last);
|
|
}
|
|
|
|
template <typename TContainer>
|
|
inline detail::outer_ring_from_iterator_pair<typename TContainer::const_iterator> _outer_ring(const TContainer& container) {
|
|
return detail::outer_ring_from_iterator_pair<typename TContainer::const_iterator>(std::begin(container), std::end(container));
|
|
}
|
|
|
|
using object_id_ilist = std::initializer_list<osmium::object_id_type>;
|
|
inline detail::outer_ring_from_iterator_pair<object_id_ilist::const_iterator> _outer_ring(const object_id_ilist& container) {
|
|
return detail::outer_ring_from_iterator_pair<object_id_ilist::const_iterator>(std::begin(container), std::end(container));
|
|
}
|
|
|
|
using node_ref_ilist = std::initializer_list<osmium::NodeRef>;
|
|
inline detail::outer_ring_from_iterator_pair<node_ref_ilist::const_iterator> _outer_ring(const node_ref_ilist& container) {
|
|
return detail::outer_ring_from_iterator_pair<node_ref_ilist::const_iterator>(std::begin(container), std::end(container));
|
|
}
|
|
|
|
template <typename TIdIterator>
|
|
inline constexpr detail::inner_ring_from_iterator_pair<TIdIterator> _inner_ring(TIdIterator first, TIdIterator last) {
|
|
return detail::inner_ring_from_iterator_pair<TIdIterator>(first, last);
|
|
}
|
|
|
|
template <typename TContainer>
|
|
inline detail::inner_ring_from_iterator_pair<typename TContainer::const_iterator> _inner_ring(const TContainer& container) {
|
|
return detail::inner_ring_from_iterator_pair<typename TContainer::const_iterator>(std::begin(container), std::end(container));
|
|
}
|
|
|
|
using object_id_ilist = std::initializer_list<osmium::object_id_type>;
|
|
inline detail::inner_ring_from_iterator_pair<object_id_ilist::const_iterator> _inner_ring(const object_id_ilist& container) {
|
|
return detail::inner_ring_from_iterator_pair<object_id_ilist::const_iterator>(std::begin(container), std::end(container));
|
|
}
|
|
|
|
using node_ref_ilist = std::initializer_list<osmium::NodeRef>;
|
|
inline detail::inner_ring_from_iterator_pair<node_ref_ilist::const_iterator> _inner_ring(const node_ref_ilist& container) {
|
|
return detail::inner_ring_from_iterator_pair<node_ref_ilist::const_iterator>(std::begin(container), std::end(container));
|
|
}
|
|
|
|
|
|
} // namespace attr
|
|
|
|
#undef OSMIUM_ATTRIBUTE_ITER
|
|
#undef OSMIUM_ATTRIBUTE_WITH_CONSTRUCTOR
|
|
#undef OSMIUM_ATTRIBUTE
|
|
|
|
namespace detail {
|
|
|
|
struct changeset_handler : public entity_handler {
|
|
|
|
template <typename TDummy>
|
|
static void set_value(osmium::Changeset&, const TDummy&) noexcept {
|
|
}
|
|
|
|
static void set_value(osmium::Changeset& changeset, attr::_cid id) noexcept {
|
|
changeset.set_id(id.value);
|
|
}
|
|
|
|
static void set_value(osmium::Changeset& changeset, attr::_num_changes num_changes) noexcept {
|
|
changeset.set_num_changes(num_changes.value);
|
|
}
|
|
|
|
static void set_value(osmium::Changeset& changeset, attr::_num_comments num_comments) noexcept {
|
|
changeset.set_num_comments(num_comments.value);
|
|
}
|
|
|
|
static void set_value(osmium::Changeset& changeset, attr::_created_at created_at) noexcept {
|
|
changeset.set_created_at(created_at.value);
|
|
}
|
|
|
|
static void set_value(osmium::Changeset& changeset, attr::_closed_at closed_at) noexcept {
|
|
changeset.set_closed_at(closed_at.value);
|
|
}
|
|
|
|
static void set_value(osmium::Changeset& changeset, attr::_uid uid) noexcept {
|
|
changeset.set_uid(uid.value);
|
|
}
|
|
|
|
};
|
|
|
|
struct object_handler : public entity_handler {
|
|
|
|
template <typename TDummy>
|
|
static void set_value(osmium::OSMObject&, const TDummy&) noexcept {
|
|
}
|
|
|
|
static void set_value(osmium::OSMObject& object, attr::_id id) noexcept {
|
|
object.set_id(id.value);
|
|
}
|
|
|
|
static void set_value(osmium::OSMObject& object, attr::_version version) noexcept {
|
|
object.set_version(version.value);
|
|
}
|
|
|
|
static void set_value(osmium::OSMObject& object, attr::_visible visible) noexcept {
|
|
object.set_visible(visible.value);
|
|
}
|
|
|
|
static void set_value(osmium::OSMObject& object, attr::_deleted deleted) noexcept {
|
|
object.set_deleted(deleted.value);
|
|
}
|
|
|
|
static void set_value(osmium::OSMObject& object, attr::_timestamp timestamp) noexcept {
|
|
object.set_timestamp(timestamp.value);
|
|
}
|
|
|
|
static void set_value(osmium::OSMObject& object, attr::_cid changeset) noexcept {
|
|
object.set_changeset(changeset.value);
|
|
}
|
|
|
|
static void set_value(osmium::OSMObject& object, attr::_uid uid) noexcept {
|
|
object.set_uid(uid.value);
|
|
}
|
|
|
|
}; // object_handler
|
|
|
|
struct node_handler : public object_handler {
|
|
|
|
using object_handler::set_value;
|
|
|
|
static void set_value(osmium::Node& node, attr::_location location) noexcept {
|
|
node.set_location(location.value);
|
|
}
|
|
|
|
}; // node_handler
|
|
|
|
template <typename THandler, typename TBuilder, typename... TArgs>
|
|
inline void add_basic(TBuilder& builder, const TArgs&... args) noexcept {
|
|
(void)std::initializer_list<int>{
|
|
(THandler::set_value(builder.object(), args), 0)...
|
|
};
|
|
}
|
|
|
|
// ==============================================================
|
|
|
|
template <typename... TArgs>
|
|
inline constexpr const char* get_user(const attr::_user& user, const TArgs&...) noexcept {
|
|
return user.value;
|
|
}
|
|
|
|
inline constexpr const char* get_user() noexcept {
|
|
return "";
|
|
}
|
|
|
|
template <typename TFirst, typename... TRest>
|
|
inline constexpr typename std::enable_if<!std::is_same<attr::_user, TFirst>::value, const char*>::type
|
|
get_user(const TFirst&, const TRest&... args) noexcept {
|
|
return get_user(args...);
|
|
}
|
|
|
|
template <typename TBuilder, typename... TArgs>
|
|
inline void add_user(TBuilder& builder, const TArgs&... args) {
|
|
builder.set_user(get_user(args...));
|
|
}
|
|
|
|
// ==============================================================
|
|
|
|
struct tags_handler {
|
|
|
|
template <typename TDummy>
|
|
static void set_value(TagListBuilder&, const TDummy&) noexcept {
|
|
}
|
|
|
|
static void set_value(TagListBuilder& builder, const attr::_tag& tag) {
|
|
builder.add_tag(tag.value);
|
|
}
|
|
|
|
template <typename TIterator>
|
|
static void set_value(TagListBuilder& builder, const attr::detail::tags_from_iterator_pair<TIterator>& tags) {
|
|
for (const auto& tag : tags) {
|
|
builder.add_tag(tag);
|
|
}
|
|
}
|
|
|
|
}; // struct tags_handler
|
|
|
|
struct nodes_handler {
|
|
|
|
template <typename TDummy>
|
|
static void set_value(WayNodeListBuilder&, const TDummy&) noexcept {
|
|
}
|
|
|
|
static void set_value(WayNodeListBuilder& builder, const attr::_node& node_ref) {
|
|
builder.add_node_ref(node_ref.value);
|
|
}
|
|
|
|
template <typename TIterator>
|
|
static void set_value(WayNodeListBuilder& builder, const attr::detail::nodes_from_iterator_pair<TIterator>& nodes) {
|
|
for (const auto& ref : nodes) {
|
|
builder.add_node_ref(ref);
|
|
}
|
|
}
|
|
|
|
}; // struct nodes_handler
|
|
|
|
struct members_handler {
|
|
|
|
template <typename TDummy>
|
|
static void set_value(RelationMemberListBuilder&, const TDummy&) noexcept {
|
|
}
|
|
|
|
static void set_value(RelationMemberListBuilder& builder, const attr::_member& member) {
|
|
builder.add_member(member.value.type(), member.value.ref(), member.value.role());
|
|
}
|
|
|
|
template <typename TIterator>
|
|
static void set_value(RelationMemberListBuilder& builder, const attr::detail::members_from_iterator_pair<TIterator>& members) {
|
|
for (const auto& member : members) {
|
|
builder.add_member(member.type(), member.ref(), member.role());
|
|
}
|
|
}
|
|
|
|
}; // struct members_handler
|
|
|
|
struct discussion_handler {
|
|
|
|
template <typename TDummy>
|
|
static void set_value(ChangesetDiscussionBuilder&, const TDummy&) noexcept {
|
|
}
|
|
|
|
static void set_value(ChangesetDiscussionBuilder& builder, const attr::_comment& comment) {
|
|
builder.add_comment(comment.value.date(), comment.value.uid(), comment.value.user());
|
|
builder.add_comment_text(comment.value.text());
|
|
}
|
|
|
|
template <typename TIterator>
|
|
static void set_value(ChangesetDiscussionBuilder& builder, const attr::detail::comments_from_iterator_pair<TIterator>& comments) {
|
|
for (const auto& comment : comments) {
|
|
builder.add_comment(comment.date(), comment.uid(), comment.user());
|
|
builder.add_comment_text(comment.text());
|
|
}
|
|
}
|
|
|
|
}; // struct discussion_handler
|
|
|
|
struct ring_handler {
|
|
|
|
template <typename TDummy>
|
|
static void set_value(AreaBuilder&, const TDummy&) noexcept {
|
|
}
|
|
|
|
template <typename TIterator>
|
|
static void set_value(AreaBuilder& parent, const attr::detail::outer_ring_from_iterator_pair<TIterator>& nodes) {
|
|
OuterRingBuilder builder(parent.buffer(), &parent);
|
|
for (const auto& ref : nodes) {
|
|
builder.add_node_ref(ref);
|
|
}
|
|
}
|
|
|
|
template <typename TIterator>
|
|
static void set_value(AreaBuilder& parent, const attr::detail::inner_ring_from_iterator_pair<TIterator>& nodes) {
|
|
InnerRingBuilder builder(parent.buffer(), &parent);
|
|
for (const auto& ref : nodes) {
|
|
builder.add_node_ref(ref);
|
|
}
|
|
}
|
|
|
|
}; // struct ring_handler
|
|
|
|
// ==============================================================
|
|
|
|
template <typename TBuilder, typename THandler, typename... TArgs>
|
|
inline typename std::enable_if<!is_handled_by<THandler, TArgs...>::value>::type
|
|
add_list(osmium::builder::Builder&, const TArgs&...) noexcept {
|
|
}
|
|
|
|
template <typename TBuilder, typename THandler, typename... TArgs>
|
|
inline typename std::enable_if<is_handled_by<THandler, TArgs...>::value>::type
|
|
add_list(osmium::builder::Builder& parent, const TArgs&... args) {
|
|
TBuilder builder(parent.buffer(), &parent);
|
|
(void)std::initializer_list<int>{
|
|
(THandler::set_value(builder, args), 0)...
|
|
};
|
|
}
|
|
|
|
struct any_node_handlers : public node_handler, public tags_handler {};
|
|
struct any_way_handlers : public object_handler, public tags_handler, public nodes_handler {};
|
|
struct any_relation_handlers : public object_handler, public tags_handler, public members_handler {};
|
|
struct any_area_handlers : public object_handler, public tags_handler, public ring_handler {};
|
|
struct any_changeset_handlers : public changeset_handler, public tags_handler, public discussion_handler {};
|
|
|
|
} // namespace detail
|
|
|
|
|
|
/**
|
|
* Create a node using the given arguments and add it to the given buffer.
|
|
*
|
|
* @param buffer The buffer to which the node will be added.
|
|
* @param args The attributes of the node.
|
|
* @returns The position in the buffer where this node was added.
|
|
*/
|
|
template <typename... TArgs>
|
|
inline size_t add_node(osmium::memory::Buffer& buffer, const TArgs&... args) {
|
|
static_assert(sizeof...(args) > 0, "add_node() must have buffer and at least one additional argument");
|
|
static_assert(detail::are_all_handled_by<detail::any_node_handlers, TArgs...>::value, "Attribute not allowed in add_node()");
|
|
|
|
{
|
|
NodeBuilder builder(buffer);
|
|
|
|
detail::add_basic<detail::node_handler>(builder, args...);
|
|
detail::add_user(builder, args...);
|
|
detail::add_list<TagListBuilder, detail::tags_handler>(builder, args...);
|
|
}
|
|
|
|
return buffer.commit();
|
|
}
|
|
|
|
/**
|
|
* Create a way using the given arguments and add it to the given buffer.
|
|
*
|
|
* @param buffer The buffer to which the way will be added.
|
|
* @param args The attributes of the way.
|
|
* @returns The position in the buffer where this way was added.
|
|
*/
|
|
template <typename... TArgs>
|
|
inline size_t add_way(osmium::memory::Buffer& buffer, const TArgs&... args) {
|
|
static_assert(sizeof...(args) > 0, "add_way() must have buffer and at least one additional argument");
|
|
static_assert(detail::are_all_handled_by<detail::any_way_handlers, TArgs...>::value, "Attribute not allowed in add_way()");
|
|
|
|
{
|
|
WayBuilder builder(buffer);
|
|
|
|
detail::add_basic<detail::object_handler>(builder, args...);
|
|
detail::add_user(builder, args...);
|
|
detail::add_list<TagListBuilder, detail::tags_handler>(builder, args...);
|
|
detail::add_list<WayNodeListBuilder, detail::nodes_handler>(builder, args...);
|
|
}
|
|
|
|
return buffer.commit();
|
|
}
|
|
|
|
/**
|
|
* Create a relation using the given arguments and add it to the given buffer.
|
|
*
|
|
* @param buffer The buffer to which the relation will be added.
|
|
* @param args The attributes of the relation.
|
|
* @returns The position in the buffer where this relation was added.
|
|
*/
|
|
template <typename... TArgs>
|
|
inline size_t add_relation(osmium::memory::Buffer& buffer, const TArgs&... args) {
|
|
static_assert(sizeof...(args) > 0, "add_relation() must have buffer and at least one additional argument");
|
|
static_assert(detail::are_all_handled_by<detail::any_relation_handlers, TArgs...>::value, "Attribute not allowed in add_relation()");
|
|
|
|
{
|
|
RelationBuilder builder(buffer);
|
|
|
|
detail::add_basic<detail::object_handler>(builder, args...);
|
|
detail::add_user(builder, args...);
|
|
detail::add_list<TagListBuilder, detail::tags_handler>(builder, args...);
|
|
detail::add_list<RelationMemberListBuilder, detail::members_handler>(builder, args...);
|
|
}
|
|
|
|
return buffer.commit();
|
|
}
|
|
|
|
/**
|
|
* Create a changeset using the given arguments and add it to the given buffer.
|
|
*
|
|
* @param buffer The buffer to which the changeset will be added.
|
|
* @param args The attributes of the changeset.
|
|
* @returns The position in the buffer where this changeset was added.
|
|
*/
|
|
template <typename... TArgs>
|
|
inline size_t add_changeset(osmium::memory::Buffer& buffer, const TArgs&... args) {
|
|
static_assert(sizeof...(args) > 0, "add_changeset() must have buffer and at least one additional argument");
|
|
static_assert(detail::are_all_handled_by<detail::any_changeset_handlers, TArgs...>::value, "Attribute not allowed in add_changeset()");
|
|
|
|
{
|
|
ChangesetBuilder builder(buffer);
|
|
|
|
detail::add_basic<detail::changeset_handler>(builder, args...);
|
|
detail::add_user(builder, args...);
|
|
detail::add_list<TagListBuilder, detail::tags_handler>(builder, args...);
|
|
detail::add_list<ChangesetDiscussionBuilder, detail::discussion_handler>(builder, args...);
|
|
}
|
|
|
|
return buffer.commit();
|
|
}
|
|
|
|
/**
|
|
* Create a area using the given arguments and add it to the given buffer.
|
|
*
|
|
* @param buffer The buffer to which the area will be added.
|
|
* @param args The attributes of the area.
|
|
* @returns The position in the buffer where this area was added.
|
|
*/
|
|
template <typename... TArgs>
|
|
inline size_t add_area(osmium::memory::Buffer& buffer, const TArgs&... args) {
|
|
static_assert(sizeof...(args) > 0, "add_area() must have buffer and at least one additional argument");
|
|
static_assert(detail::are_all_handled_by<detail::any_area_handlers, TArgs...>::value, "Attribute not allowed in add_area()");
|
|
|
|
{
|
|
AreaBuilder builder(buffer);
|
|
|
|
detail::add_basic<detail::object_handler>(builder, args...);
|
|
detail::add_user(builder, args...);
|
|
detail::add_list<TagListBuilder, detail::tags_handler>(builder, args...);
|
|
|
|
(void)std::initializer_list<int>{
|
|
(detail::ring_handler::set_value(builder, args), 0)...
|
|
};
|
|
}
|
|
|
|
return buffer.commit();
|
|
}
|
|
|
|
/**
|
|
* Create a WayNodeList using the given arguments and add it to the given buffer.
|
|
*
|
|
* @param buffer The buffer to which the list will be added.
|
|
* @param args The contents of the list.
|
|
* @returns The position in the buffer where this list was added.
|
|
*/
|
|
template <typename... TArgs>
|
|
inline size_t add_way_node_list(osmium::memory::Buffer& buffer, const TArgs&... args) {
|
|
static_assert(sizeof...(args) > 0, "add_way_node_list() must have buffer and at least one additional argument");
|
|
static_assert(detail::are_all_handled_by<detail::nodes_handler, TArgs...>::value, "Attribute not allowed in add_way_node_list()");
|
|
|
|
{
|
|
WayNodeListBuilder builder(buffer);
|
|
(void)std::initializer_list<int>{
|
|
(detail::nodes_handler::set_value(builder, args), 0)...
|
|
};
|
|
}
|
|
|
|
return buffer.commit();
|
|
}
|
|
|
|
/**
|
|
* Create a TagList using the given arguments and add it to the given buffer.
|
|
*
|
|
* @param buffer The buffer to which the list will be added.
|
|
* @param args The contents of the list.
|
|
* @returns The position in the buffer where this list was added.
|
|
*/
|
|
template <typename... TArgs>
|
|
inline size_t add_tag_list(osmium::memory::Buffer& buffer, const TArgs&... args) {
|
|
static_assert(sizeof...(args) > 0, "add_tag_list() must have buffer and at least one additional argument");
|
|
static_assert(detail::are_all_handled_by<detail::tags_handler, TArgs...>::value, "Attribute not allowed in add_tag_list()");
|
|
|
|
{
|
|
TagListBuilder builder(buffer);
|
|
(void)std::initializer_list<int>{
|
|
(detail::tags_handler::set_value(builder, args), 0)...
|
|
};
|
|
}
|
|
|
|
return buffer.commit();
|
|
}
|
|
|
|
} // namespace builder
|
|
|
|
} // namespace osmium
|
|
|
|
#endif // OSMIUM_BUILDER_ATTR_HPP
|