1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
#ifndef VTZERO_FEATURE_BUILDER_IMPL_HPP
#define VTZERO_FEATURE_BUILDER_IMPL_HPP
/*****************************************************************************
vtzero - Tiny and fast vector tile decoder and encoder in C++.
This file is from https://github.com/mapbox/vtzero where you can find more
documentation.
*****************************************************************************/
/**
* @file feature_builder_impl.hpp
*
* @brief Contains classes internal to the builder.
*/
#include "builder_impl.hpp"
#include "encoded_property_value.hpp"
#include "geometry.hpp"
#include "property.hpp"
#include "property_value.hpp"
#include <utility>
namespace vtzero {
namespace detail {
class feature_builder_base {
layer_builder_impl* m_layer;
void add_key_internal(index_value idx) {
vtzero_assert(idx.valid());
m_pbf_tags.add_element(idx.value());
}
template <typename T>
void add_key_internal(T&& key) {
add_key_internal(m_layer->add_key(data_view{std::forward<T>(key)}));
}
void add_value_internal(index_value idx) {
vtzero_assert(idx.valid());
m_pbf_tags.add_element(idx.value());
}
void add_value_internal(property_value value) {
add_value_internal(m_layer->add_value(value));
}
template <typename T>
void add_value_internal(T&& value) {
encoded_property_value v{std::forward<T>(value)};
add_value_internal(m_layer->add_value(v));
}
protected:
protozero::pbf_builder<detail::pbf_feature> m_feature_writer;
protozero::packed_field_uint32 m_pbf_tags;
explicit feature_builder_base(layer_builder_impl* layer) :
m_layer(layer),
m_feature_writer(layer->message(), detail::pbf_layer::features) {
}
~feature_builder_base() noexcept = default;
feature_builder_base(const feature_builder_base&) = delete; // NOLINT(hicpp-use-equals-delete, modernize-use-equals-delete)
feature_builder_base& operator=(const feature_builder_base&) = delete; // NOLINT(hicpp-use-equals-delete, modernize-use-equals-delete)
// The check wants these functions to be public...
feature_builder_base(feature_builder_base&&) noexcept = default;
feature_builder_base& operator=(feature_builder_base&&) noexcept = default;
uint32_t version() const noexcept {
return m_layer->version();
}
void set_id_impl(uint64_t id) {
m_feature_writer.add_uint64(detail::pbf_feature::id, id);
}
void add_property_impl(const property& property) {
add_key_internal(property.key());
add_value_internal(property.value());
}
void add_property_impl(const index_value_pair idxs) {
add_key_internal(idxs.key());
add_value_internal(idxs.value());
}
template <typename TKey, typename TValue>
void add_property_impl(TKey&& key, TValue&& value) {
add_key_internal(std::forward<TKey>(key));
add_value_internal(std::forward<TValue>(value));
}
void do_commit() {
if (m_pbf_tags.valid()) {
m_pbf_tags.commit();
}
m_feature_writer.commit();
m_layer->increment_feature_count();
}
void do_rollback() {
if (m_pbf_tags.valid()) {
m_pbf_tags.rollback();
}
m_feature_writer.rollback();
}
}; // class feature_builder_base
} // namespace detail
} // namespace vtzero
#endif // VTZERO_FEATURE_BUILDER_IMPL_HPP
|
