NS-3 based Named Data Networking (NDN) simulator
ndnSIM 2.5: NDN, CCN, CCNx, content centric networks
API Documentation
block-helpers.hpp
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2013-2022 Regents of the University of California.
4  *
5  * This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
6  *
7  * ndn-cxx library is free software: you can redistribute it and/or modify it under the
8  * terms of the GNU Lesser General Public License as published by the Free Software
9  * Foundation, either version 3 of the License, or (at your option) any later version.
10  *
11  * ndn-cxx library is distributed in the hope that it will be useful, but WITHOUT ANY
12  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
13  * PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
14  *
15  * You should have received copies of the GNU General Public License and GNU Lesser
16  * General Public License along with ndn-cxx, e.g., in COPYING.md file. If not, see
17  * <http://www.gnu.org/licenses/>.
18  *
19  * See AUTHORS.md for complete list of ndn-cxx authors and contributors.
20  */
21 
22 #ifndef NDN_CXX_ENCODING_BLOCK_HELPERS_HPP
23 #define NDN_CXX_ENCODING_BLOCK_HELPERS_HPP
24 
28 
29 namespace ndn {
30 namespace encoding {
31 
38 template<Tag TAG>
39 size_t
40 prependNonNegativeIntegerBlock(EncodingImpl<TAG>& encoder, uint32_t type, uint64_t value);
41 
42 extern template size_t
43 prependNonNegativeIntegerBlock<EstimatorTag>(EncodingImpl<EstimatorTag>&, uint32_t, uint64_t);
44 
45 extern template size_t
46 prependNonNegativeIntegerBlock<EncoderTag>(EncodingImpl<EncoderTag>&, uint32_t, uint64_t);
47 
53 Block
54 makeNonNegativeIntegerBlock(uint32_t type, uint64_t value);
55 
61 uint64_t
62 readNonNegativeInteger(const Block& block);
63 
70 template<typename R>
73 {
74  uint64_t value = readNonNegativeInteger(block);
75  if (value > std::numeric_limits<R>::max()) {
76  NDN_THROW(tlv::Error("Value in TLV element of type " + to_string(block.type()) + " is too large"));
77  }
78  return static_cast<R>(value);
79 }
80 
89 template<typename R>
92 {
93  return static_cast<R>(readNonNegativeIntegerAs<std::underlying_type_t<R>>(block));
94 }
95 
102 template<Tag TAG>
103 size_t
104 prependEmptyBlock(EncodingImpl<TAG>& encoder, uint32_t type);
105 
106 extern template size_t
107 prependEmptyBlock<EstimatorTag>(EncodingImpl<EstimatorTag>&, uint32_t);
108 
109 extern template size_t
110 prependEmptyBlock<EncoderTag>(EncodingImpl<EncoderTag>&, uint32_t);
111 
117 Block
118 makeEmptyBlock(uint32_t type);
119 
126 template<Tag TAG>
127 size_t
128 prependStringBlock(EncodingImpl<TAG>& encoder, uint32_t type, const std::string& value);
129 
130 extern template size_t
131 prependStringBlock<EstimatorTag>(EncodingImpl<EstimatorTag>&, uint32_t, const std::string&);
132 
133 extern template size_t
134 prependStringBlock<EncoderTag>(EncodingImpl<EncoderTag>&, uint32_t, const std::string&);
135 
141 Block
142 makeStringBlock(uint32_t type, const std::string& value);
143 
149 std::string
150 readString(const Block& block);
151 
158 template<Tag TAG>
159 size_t
160 prependDoubleBlock(EncodingImpl<TAG>& encoder, uint32_t type, double value);
161 
162 extern template size_t
163 prependDoubleBlock<EstimatorTag>(EncodingImpl<EstimatorTag>&, uint32_t, double);
164 
165 extern template size_t
166 prependDoubleBlock<EncoderTag>(EncodingImpl<EncoderTag>&, uint32_t, double);
167 
173 Block
174 makeDoubleBlock(uint32_t type, double value);
175 
181 double
182 readDouble(const Block& block);
183 
191 template<Tag TAG>
192 size_t
193 prependBinaryBlock(EncodingImpl<TAG>& encoder, uint32_t type, span<const uint8_t> value);
194 
195 extern template size_t
196 prependBinaryBlock<EstimatorTag>(EncodingImpl<EstimatorTag>&, uint32_t, span<const uint8_t>);
197 
198 extern template size_t
199 prependBinaryBlock<EncoderTag>(EncodingImpl<EncoderTag>&, uint32_t, span<const uint8_t>);
200 
207 Block
208 makeBinaryBlock(uint32_t type, span<const uint8_t> value);
209 
216 inline Block
217 makeBinaryBlock(uint32_t type, const char* value, size_t length)
218 {
219  return makeBinaryBlock(type, {reinterpret_cast<const uint8_t*>(value), length});
220 }
221 
222 namespace detail {
223 
227 template<class Iterator>
229 {
230 public:
231  BOOST_CONCEPT_ASSERT((boost::RandomAccessIterator<Iterator>));
232 
233  static Block
234  makeBlock(uint32_t type, Iterator first, Iterator last)
235  {
236  EncodingEstimator estimator;
237  size_t valueLength = last - first;
238  size_t totalLength = valueLength;
239  totalLength += estimator.prependVarNumber(valueLength);
240  totalLength += estimator.prependVarNumber(type);
241 
242  EncodingBuffer encoder(totalLength, 0);
243  encoder.prependRange(first, last);
244  encoder.prependVarNumber(valueLength);
245  encoder.prependVarNumber(type);
246 
247  return encoder.block();
248  }
249 };
250 
254 template<class Iterator>
256 {
257 public:
258  BOOST_CONCEPT_ASSERT((boost::InputIterator<Iterator>));
259 
260  static Block
261  makeBlock(uint32_t type, Iterator first, Iterator last)
262  {
263  // reserve 4 bytes in front (common for 1(type)-3(length) encoding
264  // Actual size will be adjusted as necessary by the encoder
265  EncodingBuffer encoder(4, 4);
266  size_t valueLength = encoder.appendRange(first, last);
267  encoder.prependVarNumber(valueLength);
268  encoder.prependVarNumber(type);
269 
270  return encoder.block();
271  }
272 };
273 
274 } // namespace detail
275 
284 template<class Iterator>
285 Block
286 makeBinaryBlock(uint32_t type, Iterator first, Iterator last)
287 {
288  using BinaryBlockHelper = std::conditional_t<
289  std::is_base_of<std::random_access_iterator_tag,
290  typename std::iterator_traits<Iterator>::iterator_category>::value,
293 
294  return BinaryBlockHelper::makeBlock(type, first, last);
295 }
296 
302 template<Tag TAG>
303 size_t
304 prependBlock(EncodingImpl<TAG>& encoder, const Block& block);
305 
306 extern template size_t
307 prependBlock<EstimatorTag>(EncodingImpl<EstimatorTag>&, const Block&);
308 
309 extern template size_t
310 prependBlock<EncoderTag>(EncodingImpl<EncoderTag>&, const Block&);
311 
319 template<Tag TAG, class U>
320 size_t
321 prependNestedBlock(EncodingImpl<TAG>& encoder, uint32_t type, const U& value)
322 {
323  BOOST_CONCEPT_ASSERT((WireEncodableWithEncodingBuffer<U>));
324 
325  size_t length = value.wireEncode(encoder);
326  length += encoder.prependVarNumber(length);
327  length += encoder.prependVarNumber(type);
328  return length;
329 }
330 
337 template<class U>
338 Block
339 makeNestedBlock(uint32_t type, const U& value)
340 {
341  EncodingEstimator estimator;
342  size_t totalLength = prependNestedBlock(estimator, type, value);
343 
344  EncodingBuffer encoder(totalLength, 0);
345  prependNestedBlock(encoder, type, value);
346  return encoder.block();
347 }
348 
357 template<Tag TAG, class I>
358 size_t
359 prependNestedBlock(EncodingImpl<TAG>& encoder, uint32_t type, I first, I last)
360 {
361  BOOST_CONCEPT_ASSERT((WireEncodableWithEncodingBuffer<typename std::iterator_traits<I>::value_type>));
362 
363  auto rfirst = std::make_reverse_iterator(last);
364  auto rlast = std::make_reverse_iterator(first);
365 
366  size_t length = 0;
367  for (auto i = rfirst; i != rlast; ++i) {
368  length += i->wireEncode(encoder);
369  }
370 
371  length += encoder.prependVarNumber(length);
372  length += encoder.prependVarNumber(type);
373  return length;
374 }
375 
383 template<class I>
384 Block
385 makeNestedBlock(uint32_t type, I first, I last)
386 {
387  EncodingEstimator estimator;
388  size_t totalLength = prependNestedBlock(estimator, type, first, last);
389 
390  EncodingBuffer encoder(totalLength, 0);
391  prependNestedBlock(encoder, type, first, last);
392  return encoder.block();
393 }
394 
395 } // namespace encoding
396 
405 
406 } // namespace ndn
407 
408 #endif // NDN_CXX_ENCODING_BLOCK_HELPERS_HPP
Copyright (c) 2011-2015 Regents of the University of California.
size_t appendRange(Iterator first, Iterator last)
Append range of bytes from the range [first, last)
Definition: encoder.hpp:266
EncodingImpl specialization for actual TLV encoding.
size_t prependNonNegativeIntegerBlock(EncodingImpl< TAG > &encoder, uint32_t type, uint64_t value)
Prepend a TLV element containing a non-negative integer.
std::string to_string(const T &val)
Definition: backports.hpp:86
static Block makeBlock(uint32_t type, Iterator first, Iterator last)
Block makeEmptyBlock(uint32_t type)
Create an empty TLV block.
std::enable_if_t< std::is_integral< R >::value, R > readNonNegativeIntegerAs(const Block &block)
Read a non-negative integer from a TLV element and cast to the specified type.
template size_t prependBinaryBlock< EncoderTag >(EncodingImpl< EncoderTag > &, uint32_t, span< const uint8_t >)
Block makeDoubleBlock(uint32_t type, double value)
Create a TLV element containing an IEEE 754 double-precision floating-point number.
template size_t prependEmptyBlock< EstimatorTag >(EncodingImpl< EstimatorTag > &, uint32_t)
template size_t prependNonNegativeIntegerBlock< EstimatorTag >(EncodingImpl< EstimatorTag > &, uint32_t, uint64_t)
template size_t prependNonNegativeIntegerBlock< EncoderTag >(EncodingImpl< EncoderTag > &, uint32_t, uint64_t)
Block makeNestedBlock(uint32_t type, const U &value)
Create a TLV block containing a nested TLV element.
size_t prependNestedBlock(EncodingImpl< TAG > &encoder, uint32_t type, const U &value)
Prepend a TLV element containing a nested TLV element.
Represents a TLV element of the NDN packet format.
Definition: block.hpp:44
size_t prependStringBlock(EncodingImpl< TAG > &encoder, uint32_t type, const std::string &value)
Prepend a TLV element containing a string.
std::string readString(const Block &block)
Read TLV-VALUE of a TLV element as a string.
size_t prependVarNumber(uint64_t number)
Prepend number encoded as a VAR-NUMBER in NDN-TLV format.
Definition: encoder.cpp:110
Block makeNonNegativeIntegerBlock(uint32_t type, uint64_t value)
Create a TLV block containing a non-negative integer.
template size_t prependBlock< EncoderTag >(EncodingImpl< EncoderTag > &, const Block &)
uint64_t readNonNegativeInteger(const Block &block)
Read a non-negative integer from a TLV element.
EncodingImpl specialization for TLV size estimation.
#define NDN_THROW(e)
Definition: exception.hpp:61
Create a binary block copying from generic InputIterator.
template size_t prependEmptyBlock< EncoderTag >(EncodingImpl< EncoderTag > &, uint32_t)
a concept check for TLV abstraction with .wireEncode method
Definition: concepts.hpp:60
template size_t prependStringBlock< EncoderTag >(EncodingImpl< EncoderTag > &, uint32_t, const std::string &)
Block block(bool verifyLength=true) const
Create Block from the underlying buffer.
Definition: encoder.cpp:59
size_t prependEmptyBlock(EncodingImpl< TAG > &encoder, uint32_t type)
Prepend an empty TLV element.
template size_t prependBinaryBlock< EstimatorTag >(EncodingImpl< EstimatorTag > &, uint32_t, span< const uint8_t >)
Block makeStringBlock(uint32_t type, const std::string &value)
Create a TLV block containing a string.
size_t prependRange(Iterator first, Iterator last)
Prepend range of bytes from the range [first, last)
Definition: encoder.hpp:251
constexpr size_t prependVarNumber(uint64_t n) const noexcept
Prepend n in VarNumber encoding.
Definition: estimator.hpp:82
double readDouble(const Block &block)
Read TLV-VALUE of a TLV element as an IEEE 754 double-precision floating-point number.
size_t prependBinaryBlock(EncodingImpl< TAG > &encoder, uint32_t type, span< const uint8_t > value)
Prepend a TLV element containing a sequence of raw bytes.
template size_t prependStringBlock< EstimatorTag >(EncodingImpl< EstimatorTag > &, uint32_t, const std::string &)
template size_t prependDoubleBlock< EncoderTag >(EncodingImpl< EncoderTag > &, uint32_t, double)
Block makeBinaryBlock(uint32_t type, span< const uint8_t > value)
Create a TLV block copying the TLV-VALUE from a byte range.
template size_t prependDoubleBlock< EstimatorTag >(EncodingImpl< EstimatorTag > &, uint32_t, double)
uint32_t type() const noexcept
Return the TLV-TYPE of the Block.
Definition: block.hpp:277
size_t prependDoubleBlock(EncodingImpl< TAG > &encoder, uint32_t type, double value)
Prepend a TLV element containing an IEEE 754 double-precision floating-point number.
size_t prependBlock(EncodingImpl< TAG > &encoder, const Block &block)
Prepend a TLV element.
template size_t prependBlock< EstimatorTag >(EncodingImpl< EstimatorTag > &, const Block &)
static Block makeBlock(uint32_t type, Iterator first, Iterator last)
represents an error in TLV encoding or decoding
Definition: tlv.hpp:52
Create a binary block copying from RandomAccessIterator.