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

Commit d0482c8

Browse files
Zerg1996Zerg1996
committed
Using only repack #21 
1 parent 1181f6a commit d0482c8

File tree

6 files changed

+333
-305
lines changed

6 files changed

+333
-305
lines changed

‎include/nil/detail/repack_value.hpp

+34
Original file line numberDiff line numberDiff line change
@@ -46,8 +46,42 @@
4646
#include <nil/detail/unpack_value.hpp>
4747
#include <nil/detail/pack_value.hpp>
4848

49+
#include <nil/marshalling/algorithms/unpack.hpp>
50+
4951
namespace nil {
5052
namespace detail {
53+
template<typename TInputEndian, typename TOutputEndian, typename TInput>
54+
struct value_repack_impl {
55+
marshalling::status_type *status;
56+
TInput input;
57+
58+
value_repack_impl(const TInput &input, marshalling::status_type &status) {
59+
this->input = input;
60+
this->status = &status;
61+
}
62+
63+
template<typename T>
64+
inline operator T() {
65+
marshalling::status_type result_status_unpack, result_status_pack;
66+
67+
if constexpr(!marshalling::is_marshalling_type<TInput>::value) {
68+
using marshalling_type = typename marshalling::is_compatible<TInput>::template type<TInputEndian>;
69+
std::vector<std::uint8_t> buffer = value_unpack_impl<marshalling_type>(marshalling_type(input), result_status_unpack);
70+
T result = range_pack_impl<TOutputEndian, std::vector<std::uint8_t>::const_iterator>(
71+
buffer, result_status_pack);
72+
*status = result_status_pack | result_status_unpack;
73+
74+
return result;
75+
} else {
76+
std::vector<std::uint8_t> buffer = value_unpack_impl<TInput>(input, result_status_unpack);
77+
T result = range_pack_impl<TOutputEndian, std::vector<std::uint8_t>::const_iterator>(
78+
buffer, result_status_pack);
79+
*status = result_status_pack | result_status_unpack;
80+
81+
return result;
82+
}
83+
}
84+
};
5185

5286
template<typename TInputEndian, typename TOutputEndian, typename Iter>
5387
struct range_repack_impl {

‎include/nil/detail/unpack_value.hpp

+16-10
Original file line numberDiff line numberDiff line change
@@ -94,26 +94,29 @@ namespace nil {
9494
}
9595
};
9696

97-
template<typename TEndian, typename Input>
97+
template<typename TEndian, typename Iter>
9898
struct range_unpack_impl {
9999
marshalling::status_type *status;
100-
mutable typename std::conditional<nil::detail::is_iterator<Input>::value, Input, typename Input::const_iterator>::type iterator;
100+
mutable Iter iterator;
101101
size_t count_elements;
102-
using value_type = typename Input::value_type;
102+
using value_type = typename std::iterator_traits<Iter>::value_type;
103103

104-
range_unpack_impl(const Input &range, marshalling::status_type &status) {
104+
template <typename SinglePassRange>
105+
range_unpack_impl(const SinglePassRange &range, marshalling::status_type &status) {
105106
iterator = range.begin();
106107
count_elements = std::distance(range.begin(), range.end());
107108
this->status = &status;
108109
}
109110

110-
range_unpack_impl(Input first, Input last, marshalling::status_type &status) {
111+
template <typename InputIterator>
112+
range_unpack_impl(InputIterator first, InputIterator last, marshalling::status_type &status) {
111113
iterator = first;
112114
count_elements = std::distance(first, last);
113115
this->status = &status;
114116
}
115117

116-
range_unpack_impl(const Input &iter, size_t len, marshalling::status_type &status) {
118+
template <typename InputIterator>
119+
range_unpack_impl(const InputIterator &iter, size_t len, marshalling::status_type &status) {
117120
iterator = iter;
118121
count_elements = len;
119122
this->status = &status;
@@ -127,9 +130,11 @@ namespace nil {
127130
inline operator OutputRange() {
128131
using Toutput = typename OutputRange::value_type;
129132

130-
using marshalling_type = typename marshalling::is_compatible<Input>::template type<TEndian>;
133+
using marshalling_type = typename marshalling::is_compatible<std::vector<value_type>>::template type<TEndian>;
131134
using marshalling_internal_type = typename marshalling_type::element_type;
132-
using marshalling_vector = typename std::conditional<marshalling::is_compatible<Input>::fixed_size, nil::marshalling::container::static_vector<marshalling_internal_type, marshalling_type::max_length()>, std::vector<marshalling_internal_type>>::type;
135+
136+
// using marshalling_vector = typename std::conditional<marshalling::is_compatible<Input>::fixed_size, nil::marshalling::container::static_vector<marshalling_internal_type, marshalling_type::max_length()>, std::vector<marshalling_internal_type>>::type;
137+
using marshalling_vector = std::vector<marshalling_internal_type>;
133138
marshalling_vector values;
134139

135140
auto k = iterator;
@@ -151,10 +156,11 @@ namespace nil {
151156
(std::is_same<typename Array::value_type, bool>::value
152157
|| std::is_same<typename Array::value_type, std::uint8_t>::value)>::type>
153158
inline operator Array() {
154-
using marshalling_type = typename marshalling::is_compatible<Input>::template type<TEndian>;
159+
using marshalling_type = typename marshalling::is_compatible<std::vector<value_type>>::template type<TEndian>;
155160
using marshalling_internal_type = typename marshalling_type::element_type;
156161

157-
using marshalling_vector = typename std::conditional<marshalling::is_compatible<Input>::fixed_size, nil::marshalling::container::static_vector<marshalling_internal_type, marshalling_type::max_length()>, std::vector<marshalling_internal_type>>::type;
162+
// using marshalling_vector = typename std::conditional<marshalling::is_compatible<Input>::fixed_size, nil::marshalling::container::static_vector<marshalling_internal_type, marshalling_type::max_length()>, std::vector<marshalling_internal_type>>::type;
163+
using marshalling_vector = std::vector<marshalling_internal_type>;
158164
marshalling_vector values;
159165
auto k = iterator;
160166
for (int i = 0; i < count_elements; ++i, ++k) {

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

+66-187
Original file line numberDiff line numberDiff line change
@@ -50,27 +50,6 @@ namespace nil {
5050
* @brief Algorithms are meant to provide marshalling interface similar to STL algorithms' one.
5151
*/
5252

53-
/*!
54-
* @brief
55-
*
56-
* @ingroup marshalling_algorithms
57-
*
58-
* @tparam TEndian
59-
* @tparam SinglePassRange
60-
*
61-
* @param r
62-
*
63-
* @return
64-
*/
65-
template<typename TEndian, typename SinglePassRange>
66-
typename std::enable_if<std::is_integral<typename SinglePassRange::value_type>::value,
67-
nil::detail::range_pack_impl<TEndian, typename SinglePassRange::const_iterator>>::type
68-
pack(const SinglePassRange &r) {
69-
BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<const SinglePassRange>));
70-
status_type s;
71-
return nil::detail::range_pack_impl<TEndian, typename SinglePassRange::const_iterator>(r, s);
72-
}
73-
7453
/*!
7554
* @brief
7655
*
@@ -92,27 +71,6 @@ namespace nil {
9271
BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<const SinglePassRange>));
9372
return nil::detail::range_pack_impl<TEndian, typename SinglePassRange::const_iterator>(r, status);
9473
}
95-
/*!
96-
* @brief
97-
*
98-
* @ingroup marshalling_algorithms
99-
*
100-
* @tparam TEndian
101-
* @tparam SinglePassRange
102-
*
103-
* @param r
104-
*
105-
* @return
106-
*/
107-
template<typename TEndian, typename SinglePassRange>
108-
typename std::enable_if<nil::detail::is_range<SinglePassRange>::value
109-
&& std::is_integral<typename SinglePassRange::value_type>::value,
110-
nil::detail::range_pack_impl<TEndian, typename SinglePassRange::const_iterator>>::type
111-
pack(const SinglePassRange &r) {
112-
BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<const SinglePassRange>));
113-
status_type s;
114-
return nil::detail::range_pack_impl<TEndian, typename SinglePassRange::const_iterator>(r, s);
115-
}
11674

11775
/*!
11876
* @brief
@@ -139,32 +97,6 @@ namespace nil {
13997
return nil::detail::range_pack_impl<TEndian, InputIterator>(first, last, status);
14098
}
14199

142-
/*!
143-
* @brief
144-
*
145-
* @ingroup marshalling_algorithms
146-
*
147-
* @tparam TEndian
148-
* @tparam InputIterator
149-
*
150-
* @param first
151-
* @param last
152-
* @param status
153-
*
154-
* @return
155-
*/
156-
157-
template<typename TEndian, typename InputIterator>
158-
typename std::enable_if<
159-
nil::detail::is_iterator<InputIterator>::value
160-
&& std::is_integral<typename std::iterator_traits<InputIterator>::value_type>::value,
161-
nil::detail::range_pack_impl<TEndian, InputIterator>>::type
162-
pack(InputIterator first, InputIterator last) {
163-
BOOST_CONCEPT_ASSERT((boost::InputIteratorConcept<InputIterator>));
164-
status_type s;
165-
return nil::detail::range_pack_impl<TEndian, InputIterator>(first, last, s);
166-
}
167-
168100
/*!
169101
* @brief
170102
*
@@ -192,34 +124,6 @@ namespace nil {
192124
r, std::move(out), status);
193125
}
194126

195-
/*!
196-
* @brief
197-
*
198-
* @ingroup marshalling_algorithms
199-
*
200-
* @tparam TEndian
201-
* @tparam SinglePassRange
202-
* @tparam OutputIterator
203-
*
204-
* @param r
205-
* @param out
206-
* @param status
207-
*
208-
* @return
209-
*/
210-
template<typename TEndian, typename SinglePassRange, typename OutputIterator>
211-
typename std::enable_if<
212-
nil::detail::is_iterator<OutputIterator>::value && nil::detail::is_range<SinglePassRange>::value
213-
&& std::is_integral<typename SinglePassRange::value_type>::value
214-
&& nil::detail::is_iterator<OutputIterator>::value,
215-
nil::detail::itr_pack_impl<TEndian, typename SinglePassRange::const_iterator, OutputIterator>>::type
216-
pack(const SinglePassRange &r, OutputIterator out) {
217-
BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<const SinglePassRange>));
218-
status_type s;
219-
return nil::detail::itr_pack_impl<TEndian, typename SinglePassRange::const_iterator, OutputIterator>(
220-
r, std::move(out), s);
221-
}
222-
223127
/*!
224128
* @brief
225129
* @tparam TEndian
@@ -241,97 +145,72 @@ namespace nil {
241145
status);
242146
}
243147

244-
/*!
245-
* @brief
246-
* @tparam TEndian
247-
* @tparam InputIterator
248-
* @tparam OutputIterator
249-
* @param first
250-
* @param last
251-
* @param out
252-
* @return
253-
*/
254-
template<typename TEndian, typename InputIterator, typename OutputIterator>
255-
typename std::enable_if<nil::detail::is_iterator<InputIterator>::value
256-
&& std::is_integral<typename std::iterator_traits<InputIterator>::value_type>::value
257-
&& nil::detail::is_iterator<OutputIterator>::value,
258-
status_type>::type
259-
pack(InputIterator first, InputIterator last, OutputIterator out) {
260-
BOOST_CONCEPT_ASSERT(
261-
(boost::OutputIteratorConcept<OutputIterator,
262-
typename std::iterator_traits<OutputIterator>::value_type>));
263-
status_type status;
264-
status = nil::detail::itr_pack_impl<TEndian, InputIterator, OutputIterator>(first, last, std::move(out),
265-
status);
266-
return status;
267-
}
268-
269-
/*!
270-
* @brief
271-
* @tparam TEndian
272-
* @tparam SinglePassRange1
273-
* @tparam SinglePassRange2
274-
* @param rng_input
275-
* @param rng_output
276-
* @return
277-
*/
278-
template<typename TEndian, typename SinglePassRange1, typename SinglePassRange2>
279-
typename std::enable_if<nil::detail::is_range<SinglePassRange1>::value
280-
&& nil::detail::is_range<SinglePassRange2>::value
281-
&& !nil::detail::is_array<SinglePassRange2>::value,
282-
status_type>::type
283-
pack(const SinglePassRange1 &rng_input, SinglePassRange2 &rng_output) {
284-
BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<const SinglePassRange1>));
285-
BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<const SinglePassRange2>));
286-
status_type status;
287-
std::vector<typename SinglePassRange2::value_type> v = pack<TEndian>(rng_input, status);
288-
rng_output = SinglePassRange2(v.begin(), v.end());
289-
return status;
290-
}
291-
292-
/*!
293-
* @brief
294-
* @tparam TEndian
295-
* @tparam SinglePassRange
296-
* @tparam TOutput
297-
* @param rng_input
298-
* @param rng_output
299-
* @return
300-
*/
301-
template<typename TEndian, typename SinglePassRange, typename TOutput>
302-
typename std::enable_if<!(nil::detail::is_range<TOutput>::value || nil::detail::is_iterator<TOutput>::value)
303-
|| nil::detail::is_array<TOutput>::value,
304-
status_type>::type
305-
pack(const SinglePassRange &rng_input, TOutput &rng_output) {
306-
BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<const SinglePassRange>));
307-
status_type status;
308-
rng_output = pack<TEndian>(rng_input, status);
309-
return status;
310-
}
311-
312-
/*!
313-
* @brief
314-
* @tparam TEndian
315-
* @tparam InputIterator
316-
* @tparam SinglePassRange
317-
* @param first
318-
* @param last
319-
* @param rng_output
320-
* @return
321-
*/
322-
template<typename TEndian, typename InputIterator, typename SinglePassRange>
323-
typename std::enable_if<nil::detail::is_iterator<InputIterator>::value
324-
&& nil::detail::is_range<SinglePassRange>::value
325-
&& !(nil::detail::is_array<SinglePassRange>::value),
326-
status_type>::type
327-
pack(InputIterator first, InputIterator last, SinglePassRange &rng_output) {
328-
BOOST_CONCEPT_ASSERT((boost::InputIteratorConcept<InputIterator>));
329-
BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<const SinglePassRange>));
330-
status_type status;
331-
std::vector<typename SinglePassRange::value_type> v = pack<TEndian>(first, last, status);
332-
rng_output = SinglePassRange(v.begin(), v.end());
333-
return status;
334-
}
148+
// /*!
149+
// * @brief
150+
// * @tparam TEndian
151+
// * @tparam SinglePassRange1
152+
// * @tparam SinglePassRange2
153+
// * @param rng_input
154+
// * @param rng_output
155+
// * @return
156+
// */
157+
// template<typename TEndian, typename SinglePassRange1, typename SinglePassRange2>
158+
// typename std::enable_if<nil::detail::is_range<SinglePassRange1>::value
159+
// && nil::detail::is_range<SinglePassRange2>::value
160+
// && !nil::detail::is_array<SinglePassRange2>::value,
161+
// status_type>::type
162+
// pack(const SinglePassRange1 &rng_input, SinglePassRange2 &rng_output) {
163+
// BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<const SinglePassRange1>));
164+
// BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<const SinglePassRange2>));
165+
// status_type status;
166+
// std::vector<typename SinglePassRange2::value_type> v = pack<TEndian>(rng_input, status);
167+
// rng_output = SinglePassRange2(v.begin(), v.end());
168+
// return status;
169+
// }
170+
171+
// /*!
172+
// * @brief
173+
// * @tparam TEndian
174+
// * @tparam SinglePassRange
175+
// * @tparam TOutput
176+
// * @param rng_input
177+
// * @param rng_output
178+
// * @return
179+
// */
180+
// template<typename TEndian, typename SinglePassRange, typename TOutput>
181+
// typename std::enable_if<!(nil::detail::is_range<TOutput>::value || nil::detail::is_iterator<TOutput>::value)
182+
// || nil::detail::is_array<TOutput>::value,
183+
// status_type>::type
184+
// pack(const SinglePassRange &rng_input, TOutput &rng_output) {
185+
// BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<const SinglePassRange>));
186+
// status_type status;
187+
// rng_output = pack<TEndian>(rng_input, status);
188+
// return status;
189+
// }
190+
191+
// /*!
192+
// * @brief
193+
// * @tparam TEndian
194+
// * @tparam InputIterator
195+
// * @tparam SinglePassRange
196+
// * @param first
197+
// * @param last
198+
// * @param rng_output
199+
// * @return
200+
// */
201+
// template<typename TEndian, typename InputIterator, typename SinglePassRange>
202+
// typename std::enable_if<nil::detail::is_iterator<InputIterator>::value
203+
// && nil::detail::is_range<SinglePassRange>::value
204+
// && !(nil::detail::is_array<SinglePassRange>::value),
205+
// status_type>::type
206+
// pack(InputIterator first, InputIterator last, SinglePassRange &rng_output) {
207+
// BOOST_CONCEPT_ASSERT((boost::InputIteratorConcept<InputIterator>));
208+
// BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<const SinglePassRange>));
209+
// status_type status;
210+
// std::vector<typename SinglePassRange::value_type> v = pack<TEndian>(first, last, status);
211+
// rng_output = SinglePassRange(v.begin(), v.end());
212+
// return status;
213+
// }
335214

336215
/*!
337216
* @brief

0 commit comments

Comments
 (0)