Skip to content
This repository was archived by the owner on Feb 17, 2025. It is now read-only.

Commit 4d3f42c

Browse files
Zerg1996Zerg1996
committed
Add bool type #21 
1 parent 415270f commit 4d3f42c

File tree

5 files changed

+51
-162
lines changed

5 files changed

+51
-162
lines changed

‎include/nil/marshalling/algorithms/repack.hpp

+13-13
Original file line numberDiff line numberDiff line change
@@ -117,7 +117,7 @@ namespace nil {
117117
repack(const SinglePassRange &rng_input, TOutputIterator out, status_type &status) {
118118
BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<const SinglePassRange>));
119119
using T = typename std::iterator_traits<TOutputIterator>::value_type;
120-
std::vector<T> result = repack<TInputEndian, TOutputEndian>(rng_input, status);
120+
std::vector<T> result = repack<TOutputEndian, TInputEndian>(rng_input, status);
121121
return std::move(result.cbegin(), result.cend(), out);
122122
}
123123

@@ -127,7 +127,7 @@ namespace nil {
127127
TOutputIterator>::type
128128
repack(InputIterator first, InputIterator last, TOutputIterator out, status_type &status) {
129129
using T = typename std::iterator_traits<TOutputIterator>::value_type;
130-
std::vector<T> result = repack<TInputEndian, TOutputEndian>(first, last, status);
130+
std::vector<T> result = repack<TOutputEndian, TInputEndian>(first, last, status);
131131
return std::move(result.cbegin(), result.cend(), out);
132132
}
133133

@@ -141,7 +141,7 @@ namespace nil {
141141
repack(const TInput &val, SinglePassRange &rng_output) {
142142
BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<const SinglePassRange>));
143143
status_type status;
144-
std::vector<typename SinglePassRange::value_type> result = repack<TInputEndian, TOutputEndian>(val, status);
144+
std::vector<typename SinglePassRange::value_type> result = repack<TOutputEndian, TInputEndian>(val, status);
145145
rng_output = SinglePassRange(result.begin(), result.end());
146146
return status;
147147
}
@@ -156,7 +156,7 @@ namespace nil {
156156
repack(const TInput &val, SinglePassRange &rng_output) {
157157
BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<const SinglePassRange>));
158158
status_type status;
159-
rng_output = repack<TInputEndian, TOutputEndian>(val, status);
159+
rng_output = repack<TOutputEndian, TInputEndian>(val, status);
160160
return status;
161161
}
162162

@@ -172,7 +172,7 @@ namespace nil {
172172
BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<const SinglePassRange2>));
173173
status_type status;
174174
std::vector<typename SinglePassRange2::value_type> result
175-
= repack<TInputEndian, TOutputEndian>(rng_input, status);
175+
= repack<TOutputEndian, TInputEndian>(rng_input, status);
176176
rng_output = SinglePassRange2(result.begin(), result.end());
177177
return status;
178178
}
@@ -189,7 +189,7 @@ namespace nil {
189189
BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<const SinglePassRange1>));
190190
BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<const SinglePassRange2>));
191191
status_type status;
192-
rng_output = repack<TInputEndian, TOutputEndian>(rng_input, status);
192+
rng_output = repack<TOutputEndian, TInputEndian>(rng_input, status);
193193
return status;
194194
}
195195

@@ -205,7 +205,7 @@ namespace nil {
205205
BOOST_CONCEPT_ASSERT((boost::InputIteratorConcept<InputIterator>));
206206
status_type status;
207207
std::vector<typename SinglePassRange::value_type> result
208-
= repack<TInputEndian, TOutputEndian>(first, last, status);
208+
= repack<TOutputEndian, TInputEndian>(first, last, status);
209209
rng_output = SinglePassRange(result.begin(), result.end());
210210
return status;
211211
}
@@ -220,7 +220,7 @@ namespace nil {
220220
repack(InputIterator first, InputIterator last, SinglePassRange &rng_output) {
221221
BOOST_CONCEPT_ASSERT((boost::InputIteratorConcept<InputIterator>));
222222
status_type status;
223-
rng_output = repack<TInputEndian, TOutputEndian>(first, last, status);
223+
rng_output = repack<TOutputEndian, TInputEndian>(first, last, status);
224224
return status;
225225
}
226226

@@ -232,7 +232,7 @@ namespace nil {
232232
repack(InputIterator first, InputIterator last, TOutput &rng_output) {
233233
BOOST_CONCEPT_ASSERT((boost::InputIteratorConcept<InputIterator>));
234234
status_type status;
235-
rng_output = repack<TInputEndian, TOutputEndian>(first, last, status);
235+
rng_output = repack<TOutputEndian, TInputEndian>(first, last, status);
236236
return status;
237237
}
238238

@@ -244,7 +244,7 @@ namespace nil {
244244
repack(const SinglePassRange &rng_input, TOutput &rng_output) {
245245
BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<const SinglePassRange>));
246246
status_type status;
247-
rng_output = repack<TInputEndian, TOutputEndian>(rng_input, status);
247+
rng_output = repack<TOutputEndian, TInputEndian>(rng_input, status);
248248
return status;
249249
}
250250

@@ -255,7 +255,7 @@ namespace nil {
255255
repack(const TInput &val, TOutputIterator out) {
256256
status_type status;
257257
using T = typename std::iterator_traits<TOutputIterator>::value_type;
258-
std::vector<T> result = repack<TInputEndian, TOutputEndian>(val, status);
258+
std::vector<T> result = repack<TOutputEndian, TInputEndian>(val, status);
259259
std::move(result.cbegin(), result.cend(), out);
260260
return status;
261261
}
@@ -268,7 +268,7 @@ namespace nil {
268268
BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<const SinglePassRange>));
269269
status_type status;
270270
using T = typename std::iterator_traits<TOutputIterator>::value_type;
271-
std::vector<T> result = repack<TInputEndian, TOutputEndian>(rng_input, status);
271+
std::vector<T> result = repack<TOutputEndian, TInputEndian>(rng_input, status);
272272
std::move(result.cbegin(), result.cend(), out);
273273
return status;
274274
}
@@ -280,7 +280,7 @@ namespace nil {
280280
repack(InputIterator first, InputIterator last, TOutputIterator out) {
281281
using T = typename std::iterator_traits<TOutputIterator>::value_type;
282282
status_type status;
283-
std::vector<T> result = repack<TInputEndian, TOutputEndian>(first, last, status);
283+
std::vector<T> result = repack<TOutputEndian, TInputEndian>(first, last, status);
284284
std::move(result.cbegin(), result.cend(), out);
285285
return status;
286286
}

‎include/nil/marshalling/detail/pack_value.hpp

-66
Original file line numberDiff line numberDiff line change
@@ -156,72 +156,6 @@ namespace nil {
156156
return OutputRange(result.begin(), result.end());
157157
}
158158
};
159-
160-
template<typename TEndian, typename Iter, typename OutputIterator>
161-
struct itr_pack_impl {
162-
marshalling::status_type *status;
163-
mutable Iter iterator;
164-
mutable OutputIterator out_iterator;
165-
size_t count_elements;
166-
using value_type = typename std::iterator_traits<Iter>::value_type;
167-
using output_value_type = typename std::iterator_traits<OutputIterator>::value_type;
168-
169-
template<typename SinglePassRange>
170-
itr_pack_impl(const SinglePassRange &range, OutputIterator out, marshalling::status_type &status) {
171-
out_iterator = out;
172-
iterator = range.begin();
173-
count_elements = std::distance(range.begin(), range.end());
174-
this->status = &status;
175-
}
176-
177-
template<typename InputIterator>
178-
itr_pack_impl(InputIterator first, InputIterator last, OutputIterator out,
179-
marshalling::status_type &status) {
180-
iterator = first;
181-
out_iterator = out;
182-
count_elements = std::distance(first, last);
183-
this->status = &status;
184-
}
185-
186-
template<typename InputIterator>
187-
itr_pack_impl(const InputIterator &range, size_t len, OutputIterator out,
188-
marshalling::status_type &status) {
189-
out_iterator = out;
190-
iterator = range;
191-
count_elements = len;
192-
this->status = &status;
193-
}
194-
195-
inline operator OutputIterator() const {
196-
using marshalling_type =
197-
typename marshalling::is_compatible<std::vector<output_value_type>>::template type<TEndian>;
198-
marshalling_type m_val;
199-
200-
*status = m_val.read(iterator, count_elements);
201-
std::vector<output_value_type> result;
202-
for (const auto &val_i : m_val.value()) {
203-
result.push_back(val_i.value());
204-
}
205-
206-
return std::move(result.cbegin(), result.cend(), out_iterator);
207-
}
208-
209-
inline operator marshalling::status_type() const {
210-
using marshalling_type =
211-
typename marshalling::is_compatible<std::vector<output_value_type>>::template type<TEndian>;
212-
marshalling_type m_val;
213-
214-
marshalling::status_type status;
215-
status = m_val.read(iterator, count_elements);
216-
std::vector<output_value_type> result;
217-
for (const auto &val_i : m_val.value()) {
218-
result.push_back(val_i.value());
219-
}
220-
221-
std::move(result.cbegin(), result.cend(), out_iterator);
222-
return status;
223-
}
224-
};
225159
} // namespace detail
226160
} // namespace marshalling
227161
} // namespace nil

‎include/nil/marshalling/detail/repack_value.hpp

+37-21
Original file line numberDiff line numberDiff line change
@@ -48,31 +48,10 @@ namespace nil {
4848
namespace marshalling {
4949
namespace detail {
5050

51-
// template<typename Input, typename Output>
52-
// struct only_unpack {
53-
// static const bool value = !nil::marshalling::is_supported_representation_type<typename
54-
// std::iterator_traits<Input>::value_type>::value
55-
// &&
56-
// (nil::marshalling::is_supported_representation_type<Output>::value
57-
// ||
58-
// nil::marshalling::is_supported_representation_type<typename
59-
// std::iterator_traits<Output>::value_type>::value);
60-
// };
61-
//
62-
// template<typename Input, typename Output>
63-
// struct only_pack {
64-
// static const bool value = nil::marshalling::is_supported_representation_type<
65-
// typename std::iterator_traits<Input>::value_type>::value;
66-
// };
67-
6851
template<typename TInputEndian, typename TOutputEndian, typename TInput>
6952
struct value_repack_impl {
7053
marshalling::status_type *status;
7154
TInput input;
72-
// using marshalling_type = typename
73-
// std::conditional<marshalling::is_marshalling_type<TInput>::value,
74-
// TInput, typename marshalling::is_compatible<TInput>::template
75-
// type<TInputEndian>>::type;
7655

7756
value_repack_impl(const TInput &input, marshalling::status_type &status) {
7857
this->input = input;
@@ -100,6 +79,7 @@ namespace nil {
10079
inline operator T() {
10180
marshalling::status_type status_unpack, status_pack;
10281
using marshalling_type = typename marshalling::is_compatible<TInput>::template type<TInputEndian>;
82+
10383
std::vector<std::uint8_t> buffer
10484
= value_unpack_impl<marshalling_type>(marshalling_type(input), status_unpack);
10585
T result = range_pack_impl<TOutputEndian, std::vector<std::uint8_t>::const_iterator>(buffer,
@@ -108,6 +88,42 @@ namespace nil {
10888

10989
return result;
11090
}
91+
92+
template<typename T,
93+
typename = typename std::enable_if<
94+
std::is_same<T, T>::value
95+
&& !marshalling::is_marshalling_type<TInput>::value
96+
&& (nil::marshalling::is_supported_representation_type<T>::value
97+
|| nil::marshalling::is_supported_representation_type<
98+
typename std::iterator_traits<T>::value_type>::value)>::type,
99+
bool Enable1 = true, bool Enable2 = true>
100+
inline operator T() {
101+
marshalling::status_type status_unpack;
102+
103+
using marshalling_type = typename marshalling::is_compatible<TInput>::template type<TInputEndian>;
104+
105+
T result = value_unpack_impl<marshalling_type>(marshalling_type(input), status_unpack);
106+
*status = status_unpack;
107+
108+
return result;
109+
}
110+
111+
template<typename T,
112+
typename = typename std::enable_if<
113+
std::is_same<T, T>::value
114+
&& marshalling::is_marshalling_type<TInput>::value
115+
&& (nil::marshalling::is_supported_representation_type<T>::value
116+
|| nil::marshalling::is_supported_representation_type<
117+
typename std::iterator_traits<T>::value_type>::value)>::type,
118+
bool Enable1 = true, bool Enable2 = true, bool Enable3 = true>
119+
inline operator T() {
120+
marshalling::status_type status_unpack;
121+
122+
T result = value_unpack_impl<TInput>(input, status_unpack);
123+
*status = status_unpack;
124+
125+
return result;
126+
}
111127
};
112128

113129
template<typename TInputEndian, typename TOutputEndian, typename Iter>

‎include/nil/marshalling/detail/unpack_value.hpp

-61
Original file line numberDiff line numberDiff line change
@@ -78,12 +78,6 @@ namespace nil {
7878
return result;
7979
}
8080

81-
// TODO: output type from marshalling?
82-
// template<typename OutputRange, typename = typename std::enable_if<std::is_same<typename
83-
// OutputRange::value_type, bool>::value
84-
// || std::is_same<typename
85-
// OutputRange::value_type,
86-
// std::uint8_t>::value>::type>
8781
template<typename OutputRange,
8882
typename = typename std::enable_if<std::is_constructible<
8983
OutputRange, typename std::vector<typename OutputRange::value_type>::iterator,
@@ -190,61 +184,6 @@ namespace nil {
190184
return result;
191185
}
192186
};
193-
194-
template<typename TEndian, typename Iter, typename OutputIterator>
195-
struct itr_unpack_impl {
196-
marshalling::status_type *status;
197-
mutable Iter iterator;
198-
size_t count_elements;
199-
mutable OutputIterator out_iterator;
200-
using value_type = typename std::iterator_traits<Iter>::value_type;
201-
using output_value_type = typename std::iterator_traits<OutputIterator>::value_type;
202-
203-
template<typename SinglePassRange>
204-
itr_unpack_impl(const SinglePassRange &range, OutputIterator out, marshalling::status_type &status) {
205-
out_iterator = out;
206-
iterator = range.begin();
207-
count_elements = std::distance(range.begin(), range.end());
208-
this->status = &status;
209-
}
210-
211-
template<typename InputIterator>
212-
itr_unpack_impl(InputIterator first, InputIterator last, OutputIterator out,
213-
marshalling::status_type &status) {
214-
iterator = first;
215-
out_iterator = out;
216-
count_elements = std::distance(first, last);
217-
this->status = &status;
218-
}
219-
220-
template<typename SinglePassIterator>
221-
itr_unpack_impl(const SinglePassIterator &iter, size_t len, OutputIterator out,
222-
marshalling::status_type &status) {
223-
iterator = iter;
224-
out_iterator = out;
225-
count_elements = len;
226-
this->status = &status;
227-
}
228-
229-
inline operator OutputIterator() const {
230-
using marshalling_type =
231-
typename marshalling::is_compatible<std::vector<value_type>>::template type<TEndian>;
232-
using marshalling_internal_type = typename marshalling_type::element_type;
233-
234-
std::vector<marshalling_internal_type> values;
235-
236-
auto k = iterator;
237-
for (int i = 0; i < count_elements; ++i, ++k) {
238-
values.emplace_back(*k);
239-
}
240-
241-
marshalling_type m_val = marshalling_type(values);
242-
std::vector<output_value_type> result(get_length<output_value_type>(m_val));
243-
typename std::vector<output_value_type>::iterator buffer_begin = result.begin();
244-
*status = m_val.write(buffer_begin, result.size());
245-
return std::move(result.cbegin(), result.cend(), out_iterator);
246-
}
247-
};
248187
} // namespace detail
249188
} // namespace marshalling
250189
} // namespace nil

‎include/nil/marshalling/type_traits.hpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -194,7 +194,7 @@ namespace nil {
194194
struct is_supported_representation_type {
195195
static const bool value = std::is_same<std::uint8_t, T>::value
196196
|| std::is_same<std::int8_t, T>::value
197-
|| std::is_same<char, T>::value;
197+
|| std::is_same<char, T>::value || std::is_same<bool, T>::value;
198198
};
199199

200200

0 commit comments

Comments
 (0)