blob: 523b200d9d61c56c9495306a1494dcc9d5d8d0e3 [file] [log] [blame]
Jeff Thompson25b4e612013-10-10 16:03:24 -07001/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
Jeff Thompson47eecfc2013-07-07 22:56:46 -07002/**
Jeff Thompson7687dc02013-09-13 11:54:07 -07003 * Copyright (C) 2013 Regents of the University of California.
4 * @author: Jeff Thompson <jefft0@remap.ucla.edu>
Jeff Thompsonec39fbd2013-10-04 10:56:23 -07005 * @author: Alexander Afanasyev <alexander.afanasyev@ucla.edu>
6 * @author: Zhenkai Zhu <zhenkai@cs.ucla.edu>
Jeff Thompson47eecfc2013-07-07 22:56:46 -07007 * See COPYING for copyright and distribution information.
Jeff Thompson9c41dfe2013-06-27 12:10:25 -07008 */
9
10#ifndef NDN_NAME_HPP
Jeff Thompson2d27e2f2013-08-09 12:55:00 -070011#define NDN_NAME_HPP
Jeff Thompson9c41dfe2013-06-27 12:10:25 -070012
Alexander Afanasyev95e8c2f2014-02-06 17:29:30 -080013#include "common.hpp"
14#include "name-component.hpp"
15
Alexander Afanasyevaf283d82014-01-03 13:23:34 -080016#include "encoding/block.hpp"
Wentao Shang77949212014-02-01 23:42:24 -080017#include "encoding/encoding-buffer.hpp"
Jeff Thompson25b4e612013-10-10 16:03:24 -070018
Alexander Afanasyev95e8c2f2014-02-06 17:29:30 -080019#include <boost/iterator/reverse_iterator.hpp>
20
Jeff Thompson9c41dfe2013-06-27 12:10:25 -070021namespace ndn {
Alexander Afanasyev95e8c2f2014-02-06 17:29:30 -080022
Jeff Thompsonc7d65502013-11-06 17:22:26 -080023/**
24 * A Name holds an array of Name::Component and represents an NDN name.
25 */
Alexander Afanasyevb790d952014-01-24 12:07:53 -080026class Name : public ptr_lib::enable_shared_from_this<Name> {
Jeff Thompson9c41dfe2013-06-27 12:10:25 -070027public:
Alexander Afanasyev95e8c2f2014-02-06 17:29:30 -080028 /// @brief Error that can be thrown from the block
29 struct Error : public name::Component::Error { Error(const std::string &what) : name::Component::Error(what) {} };
Alexander Afanasyevaf283d82014-01-03 13:23:34 -080030
Alexander Afanasyev95e8c2f2014-02-06 17:29:30 -080031 typedef name::Component Component;
32
33 typedef std::vector<Component> component_container;
34
35 typedef Component value_type;
36 typedef void allocator_type;
37 typedef Component& reference;
38 typedef const Component const_reference;
39 typedef Component* pointer;
40 typedef const Component* const_pointer;
41 typedef Component* iterator;
42 typedef const Component* const_iterator;
Alexander Afanasyevaf283d82014-01-03 13:23:34 -080043
Alexander Afanasyev95e8c2f2014-02-06 17:29:30 -080044 typedef boost::reverse_iterator<iterator> reverse_iterator;
45 typedef boost::reverse_iterator<const_iterator> const_reverse_iterator;
46
47 typedef component_container::difference_type difference_type;
48 typedef component_container::size_type size_type;
Jeff Thompson5a6b5ab2013-08-05 15:43:47 -070049
Jeff Thompson443398d2013-07-02 19:45:46 -070050 /**
51 * Create a new Name with no components.
52 */
Alexander Afanasyev95e8c2f2014-02-06 17:29:30 -080053 Name()
54 : m_nameBlock(Tlv::Name)
55 {
Jeff Thompson016ed642013-07-02 14:39:06 -070056 }
Alexander Afanasyev52eb20d2014-02-06 18:25:54 -080057
58 /**
59 * @brief Create Name object from wire block
60 *
61 * This is a more efficient equivalent for
62 * @code
63 * Name name;
64 * name.wireDecode(wire);
65 * @endcode
66 */
Alexander Afanasyev6d48bc12014-02-18 00:10:51 -080067 explicit
Alexander Afanasyev52eb20d2014-02-06 18:25:54 -080068 Name(const Block &wire)
69 {
70 m_nameBlock = wire;
71 m_nameBlock.parse();
72 }
Jeff Thompson3f2175b2013-07-31 17:12:47 -070073
74 /**
Jeff Thompson443398d2013-07-02 19:45:46 -070075 * Parse the uri according to the NDN URI Scheme and create the name with the components.
Jeff Thompson3f2175b2013-07-31 17:12:47 -070076 * @param uri The URI string.
Jeff Thompson443398d2013-07-02 19:45:46 -070077 */
Jeff Thompson3549ef32013-09-25 14:05:17 -070078 Name(const char* uri)
Jeff Thompson67515bd2013-08-15 17:43:22 -070079 {
80 set(uri);
81 }
Jeff Thompson5a6b5ab2013-08-05 15:43:47 -070082
Jeff Thompsone5f839b2013-06-28 12:50:38 -070083 /**
Jeff Thompson3549ef32013-09-25 14:05:17 -070084 * Parse the uri according to the NDN URI Scheme and create the name with the components.
85 * @param uri The URI string.
86 */
87 Name(const std::string& uri)
88 {
89 set(uri.c_str());
90 }
Jeff Thompsonec39fbd2013-10-04 10:56:23 -070091
Alexander Afanasyev380420b2014-02-09 20:52:29 -080092 /**
93 * @brief Fast encoding or block size estimation
94 */
95 template<bool T>
Wentao Shang77949212014-02-01 23:42:24 -080096 size_t
Alexander Afanasyev380420b2014-02-09 20:52:29 -080097 wireEncode(EncodingImpl<T> &block) const;
Wentao Shang77949212014-02-01 23:42:24 -080098
Alexander Afanasyevaf283d82014-01-03 13:23:34 -080099 const Block &
100 wireEncode() const;
Alexander Afanasyev848c61a2014-01-03 13:52:04 -0800101
102 void
103 wireDecode(const Block &wire);
Alexander Afanasyev6d48bc12014-02-18 00:10:51 -0800104
105 /**
106 * @brief Check if already has wire
107 */
108 bool
109 hasWire() const;
110
Jeff Thompsonb468c312013-07-01 17:50:14 -0700111 /**
Jeff Thompson67515bd2013-08-15 17:43:22 -0700112 * Parse the uri according to the NDN URI Scheme and set the name with the components.
Jeff Thompson7781b392013-12-17 11:45:59 -0800113 * @param uri The null-terminated URI string.
Jeff Thompson67515bd2013-08-15 17:43:22 -0700114 */
Jeff Thompson0050abe2013-09-17 12:50:25 -0700115 void
116 set(const char *uri);
Jeff Thompson67515bd2013-08-15 17:43:22 -0700117
118 /**
Jeff Thompson7781b392013-12-17 11:45:59 -0800119 * Parse the uri according to the NDN URI Scheme and set the name with the components.
120 * @param uri The URI string.
121 */
122 void
Alexander Afanasyev95e8c2f2014-02-06 17:29:30 -0800123 set(const std::string& uri)
124 {
125 set(uri.c_str());
126 }
Jeff Thompson7781b392013-12-17 11:45:59 -0800127
128 /**
Jeff Thompson0aa66f22013-09-23 13:02:13 -0700129 * Append a new component, copying from value of length valueLength.
Jeff Thompson26b0d792013-09-23 16:19:01 -0700130 * @return This name so that you can chain calls to append.
Jeff Thompsone5f839b2013-06-28 12:50:38 -0700131 */
Jeff Thompson26b0d792013-09-23 16:19:01 -0700132 Name&
Jeff Thompson97223af2013-09-24 17:01:27 -0700133 append(const uint8_t *value, size_t valueLength)
Jeff Thompson0f743452013-09-12 14:23:18 -0700134 {
Alexander Afanasyev29e5c3d2014-02-11 00:01:10 -0800135 m_nameBlock.push_back(Component(value, valueLength));
Jeff Thompson26b0d792013-09-23 16:19:01 -0700136 return *this;
Jeff Thompsone5f839b2013-06-28 12:50:38 -0700137 }
Jeff Thompsonf72b1ac2013-08-16 16:44:41 -0700138
Alexander Afanasyevbf9671d2014-02-11 13:44:13 -0800139 /**
140 * Append a new component, copying from value of length valueLength.
141 * @return This name so that you can chain calls to append.
142 */
143 template<class InputIterator>
144 Name&
145 append(InputIterator begin, InputIterator end)
146 {
147 m_nameBlock.push_back(Component(begin, end));
148 return *this;
149 }
150
Alexander Afanasyev95e8c2f2014-02-06 17:29:30 -0800151 // /**
152 // * Append a new component, copying from value.
153 // * @return This name so that you can chain calls to append.
154 // */
155 // Name&
156 // append(const Buffer& value)
157 // {
Alexander Afanasyev29e5c3d2014-02-11 00:01:10 -0800158 // m_nameBlock.push_back(value);
Alexander Afanasyev95e8c2f2014-02-06 17:29:30 -0800159 // return *this;
160 // }
Jeff Thompson0f743452013-09-12 14:23:18 -0700161
Jeff Thompson26b0d792013-09-23 16:19:01 -0700162 Name&
Alexander Afanasyevaf283d82014-01-03 13:23:34 -0800163 append(const ConstBufferPtr &value)
Jeff Thompson0f743452013-09-12 14:23:18 -0700164 {
Alexander Afanasyev29e5c3d2014-02-11 00:01:10 -0800165 m_nameBlock.push_back(value);
Jeff Thompson26b0d792013-09-23 16:19:01 -0700166 return *this;
Jeff Thompsonf72b1ac2013-08-16 16:44:41 -0700167 }
Jeff Thompsone5f839b2013-06-28 12:50:38 -0700168
Jeff Thompson21eb7212013-09-26 09:05:40 -0700169 Name&
170 append(const Component &value)
171 {
Alexander Afanasyev29e5c3d2014-02-11 00:01:10 -0800172 m_nameBlock.push_back(value);
Jeff Thompson21eb7212013-09-26 09:05:40 -0700173 return *this;
174 }
Alexander Afanasyevaf283d82014-01-03 13:23:34 -0800175
Alexander Afanasyev594cdb22014-01-03 15:11:33 -0800176 /**
177 * @brief Append name component that represented as a string
178 *
179 * Note that this method is necessary to ensure correctness and unambiguity of
180 * ``append("string")`` operations (both Component and Name can be implicitly
181 * converted from string, each having different outcomes
182 */
183 Name&
184 append(const char *value)
185 {
Alexander Afanasyev29e5c3d2014-02-11 00:01:10 -0800186 m_nameBlock.push_back(Component(value));
Alexander Afanasyev594cdb22014-01-03 15:11:33 -0800187 return *this;
188 }
189
Alexander Afanasyevaf283d82014-01-03 13:23:34 -0800190 Name&
191 append(const Block &value)
192 {
Alexander Afanasyev380420b2014-02-09 20:52:29 -0800193 if (value.type() == Tlv::NameComponent)
Alexander Afanasyev29e5c3d2014-02-11 00:01:10 -0800194 m_nameBlock.push_back(value);
Alexander Afanasyev380420b2014-02-09 20:52:29 -0800195 else
Alexander Afanasyev29e5c3d2014-02-11 00:01:10 -0800196 m_nameBlock.push_back(Block(Tlv::NameComponent, value));
Alexander Afanasyev380420b2014-02-09 20:52:29 -0800197
Alexander Afanasyevaf283d82014-01-03 13:23:34 -0800198 return *this;
199 }
Jeff Thompson21eb7212013-09-26 09:05:40 -0700200
Jeff Thompsone5f839b2013-06-28 12:50:38 -0700201 /**
Jeff Thompson26b0d792013-09-23 16:19:01 -0700202 * Append the components of the given name to this name.
203 * @param name The Name with components to append.
204 * @return This name so that you can chain calls to append.
Jeff Thompson0aa66f22013-09-23 13:02:13 -0700205 */
Jeff Thompson26b0d792013-09-23 16:19:01 -0700206 Name&
207 append(const Name& name);
Alexander Afanasyev95e8c2f2014-02-06 17:29:30 -0800208
Jeff Thompson0aa66f22013-09-23 13:02:13 -0700209 /**
Jeff Thompsone5f839b2013-06-28 12:50:38 -0700210 * Clear all the components.
211 */
Jeff Thompson0050abe2013-09-17 12:50:25 -0700212 void
Alexander Afanasyev95e8c2f2014-02-06 17:29:30 -0800213 clear()
214 {
215 m_nameBlock = Block(Tlv::Name);
Jeff Thompsone5f839b2013-06-28 12:50:38 -0700216 }
217
218 /**
Jeff Thompsond0159d72013-09-23 13:34:15 -0700219 * Get a new name, constructed as a subset of components.
220 * @param iStartComponent The index if the first component to get.
221 * @param nComponents The number of components starting at iStartComponent.
222 * @return A new name.
223 */
224 Name
225 getSubName(size_t iStartComponent, size_t nComponents) const;
226
227 /**
228 * Get a new name, constructed as a subset of components starting at iStartComponent until the end of the name.
229 * @param iStartComponent The index if the first component to get.
230 * @return A new name.
231 */
232 Name
233 getSubName(size_t iStartComponent) const;
234
235 /**
236 * Return a new Name with the first nComponents components of this Name.
Jeff Thompsoneb0358f2013-12-17 10:59:53 -0800237 * @param nComponents The number of prefix components. If nComponents is -N then return the prefix up
238 * to name.size() - N. For example getPrefix(-1) returns the name without the final component.
Jeff Thompsond0159d72013-09-23 13:34:15 -0700239 * @return A new Name.
240 */
241 Name
Jeff Thompsoneb0358f2013-12-17 10:59:53 -0800242 getPrefix(int nComponents) const
Jeff Thompsond0159d72013-09-23 13:34:15 -0700243 {
Jeff Thompsoneb0358f2013-12-17 10:59:53 -0800244 if (nComponents < 0)
Alexander Afanasyev29e5c3d2014-02-11 00:01:10 -0800245 return getSubName(0, m_nameBlock.elements_size() + nComponents);
Jeff Thompsoneb0358f2013-12-17 10:59:53 -0800246 else
247 return getSubName(0, nComponents);
Jeff Thompsond0159d72013-09-23 13:34:15 -0700248 }
249
250 /**
Jeff Thompsone6063512013-07-01 15:11:28 -0700251 * Encode this name as a URI.
Jeff Thompson3f2175b2013-07-31 17:12:47 -0700252 * @return The encoded URI.
Jeff Thompsone6063512013-07-01 15:11:28 -0700253 */
Jeff Thompson0050abe2013-09-17 12:50:25 -0700254 std::string
255 toUri() const;
Jeff Thompsone6063512013-07-01 15:11:28 -0700256
Jeff Thompson21844fc2013-08-08 14:52:51 -0700257 /**
Steve DiBenedettoc145d492014-03-11 16:35:45 -0600258 * @deprecated
Jeff Thompson8aac1992013-08-12 17:26:02 -0700259 * Append a component with the encoded segment number.
260 * @param segment The segment number.
Jeff Thompson26b0d792013-09-23 16:19:01 -0700261 * @return This name so that you can chain calls to append.
262 */
Steve DiBenedettoc145d492014-03-11 16:35:45 -0600263 DEPRECATED(Name&
Jeff Thompsond129ac12013-10-11 14:30:12 -0700264 appendSegment(uint64_t segment)
Jeff Thompson8aac1992013-08-12 17:26:02 -0700265 {
Alexander Afanasyev29e5c3d2014-02-11 00:01:10 -0800266 m_nameBlock.push_back(Component::fromNumberWithMarker(segment, 0x00));
Jeff Thompsond129ac12013-10-11 14:30:12 -0700267 return *this;
Steve DiBenedettoc145d492014-03-11 16:35:45 -0600268 })
Jeff Thompsond129ac12013-10-11 14:30:12 -0700269
270 /**
Steve DiBenedettoc145d492014-03-11 16:35:45 -0600271 * @deprecated
Jeff Thompsond129ac12013-10-11 14:30:12 -0700272 * Append a component with the encoded version number.
273 * Note that this encodes the exact value of version without converting from a time representation.
274 * @param version The version number.
275 * @return This name so that you can chain calls to append.
276 */
Steve DiBenedettoc145d492014-03-11 16:35:45 -0600277 DEPRECATED(Name&
Jeff Thompsond129ac12013-10-11 14:30:12 -0700278 appendVersion(uint64_t version)
279 {
Alexander Afanasyev29e5c3d2014-02-11 00:01:10 -0800280 m_nameBlock.push_back(Component::fromNumberWithMarker(version, 0xFD));
Jeff Thompson26b0d792013-09-23 16:19:01 -0700281 return *this;
Steve DiBenedettoc145d492014-03-11 16:35:45 -0600282 })
Alexander Afanasyev594cdb22014-01-03 15:11:33 -0800283
284 /**
Steve DiBenedettoc145d492014-03-11 16:35:45 -0600285 * @deprecated
Alexander Afanasyev594cdb22014-01-03 15:11:33 -0800286 * @brief Append a component with the encoded version number.
287 *
288 * This version of the method creates version number based on the current timestamp
289 * @return This name so that you can chain calls to append.
290 */
Steve DiBenedettoc145d492014-03-11 16:35:45 -0600291 DEPRECATED(Name&
292 appendVersion());
293
294
295 /**
296 * @brief Append a component with the encoded non-negative number.
297 * @param number The non-negative number
298 * @return This name so that you can chain calls to append.
299 */
300 Name&
301 appendNumber(uint64_t number)
302 {
303 m_nameBlock.push_back(Component::fromNumber(number));
304 return *this;
305 }
306
Jeff Thompsonec7789a2013-08-21 11:08:36 -0700307 /**
Jeff Thompson3c2ab012013-10-02 14:18:16 -0700308 * Check if this name has the same component count and components as the given name.
309 * @param name The Name to check.
310 * @return true if the names are equal, otherwise false.
311 */
312 bool
313 equals(const Name& name) const;
314
315 /**
Jeff Thompsonec7789a2013-08-21 11:08:36 -0700316 * Check if the N components of this name are the same as the first N components of the given name.
317 * @param name The Name to check.
318 * @return true if this matches the given name, otherwise false. This always returns true if this name is empty.
319 */
Jeff Thompson0050abe2013-09-17 12:50:25 -0700320 bool
Alexander Afanasyevaf283d82014-01-03 13:23:34 -0800321 isPrefixOf(const Name& name) const;
322
323 bool
324 match(const Name& name) const
325 {
326 return isPrefixOf(name);
327 }
Jeff Thompsonec7789a2013-08-21 11:08:36 -0700328
Jeff Thompsonec39fbd2013-10-04 10:56:23 -0700329 //
330 // vector equivalent interface.
331 //
Alexander Afanasyevaf283d82014-01-03 13:23:34 -0800332
333 /**
334 * @brief Check if name is emtpy
335 */
336 bool
Alexander Afanasyev95e8c2f2014-02-06 17:29:30 -0800337 empty() const { return m_nameBlock.elements().empty(); }
Jeff Thompsonec39fbd2013-10-04 10:56:23 -0700338
339 /**
340 * Get the number of components.
341 * @return The number of components.
342 */
343 size_t
Alexander Afanasyev29e5c3d2014-02-11 00:01:10 -0800344 size() const { return m_nameBlock.elements_size(); }
Jeff Thompsonec39fbd2013-10-04 10:56:23 -0700345
346 /**
347 * Get the component at the given index.
348 * @param i The index of the component, starting from 0.
349 * @return The name component at the index.
350 */
351 const Component&
Alexander Afanasyev8f9aa8bed2013-12-30 15:58:57 -0800352 get(ssize_t i) const
353 {
354 if (i >= 0)
Alexander Afanasyev95e8c2f2014-02-06 17:29:30 -0800355 return reinterpret_cast<const Component&>(m_nameBlock.elements()[i]);
Alexander Afanasyev8f9aa8bed2013-12-30 15:58:57 -0800356 else
Alexander Afanasyev95e8c2f2014-02-06 17:29:30 -0800357 return reinterpret_cast<const Component&>(m_nameBlock.elements()[size() + i]);
358 }
359
360 const Component&
361 operator [] (ssize_t i) const
362 {
363 return get(i);
Alexander Afanasyev8f9aa8bed2013-12-30 15:58:57 -0800364 }
Alexander Afanasyevc2344292014-03-02 00:08:00 +0000365
366 /**
367 * @brief Get component at the specified index
368 *
369 * Unlike get() and operator[] methods, at() checks for out of bounds
370 * and will throw Name::Error when it happens
371 *
372 * @throws Name::Error if index out of bounds
373 */
Alexander Afanasyev95e8c2f2014-02-06 17:29:30 -0800374 const Component&
375 at(ssize_t i) const
376 {
Alexander Afanasyevc2344292014-03-02 00:08:00 +0000377 if ((i >= 0 && i >= size()) || (i < 0 && i < -size()))
378 throw Error("Requested component does not exist (out of bounds)");
379
Alexander Afanasyev95e8c2f2014-02-06 17:29:30 -0800380 return get(i);
381 }
382
Jeff Thompsonafc45a92014-01-15 12:42:45 -0800383 /**
384 * Compare this to the other Name using NDN canonical ordering. If the first components of each name are not equal,
385 * this returns -1 if the first comes before the second using the NDN canonical ordering for name components, or 1 if it comes after.
386 * If they are equal, this compares the second components of each name, etc. If both names are the same up to
387 * the size of the shorter name, this returns -1 if the first name is shorter than the second or 1 if it is longer.
388 * For example, if you std::sort gives: /a/b/d /a/b/cc /c /c/a /bb . This is intuitive because all names
389 * with the prefix /a are next to each other. But it may be also be counter-intuitive because /c comes before /bb
390 * according to NDN canonical ordering since it is shorter.
391 * @param other The other Name to compare with.
392 * @return 0 If they compare equal, -1 if *this comes before other in the canonical ordering, or
393 * 1 if *this comes after other in the canonical ordering.
394 *
395 * @see http://named-data.net/doc/0.2/technical/CanonicalOrder.html
396 */
397 int
398 compare(const Name& other) const;
Jeff Thompsonec39fbd2013-10-04 10:56:23 -0700399
Jeff Thompsonec39fbd2013-10-04 10:56:23 -0700400 /**
401 * Append the component
402 * @param component The component of type T.
403 */
404 template<class T> void
405 push_back(const T &component)
406 {
407 append(component);
408 }
409
Jeff Thompson91737f52013-10-04 11:07:24 -0700410 /**
411 * Check if this name has the same component count and components as the given name.
412 * @param name The Name to check.
413 * @return true if the names are equal, otherwise false.
414 */
415 bool
416 operator == (const Name &name) const { return equals(name); }
417
418 /**
419 * Check if this name has the same component count and components as the given name.
420 * @param name The Name to check.
421 * @return true if the names are not equal, otherwise false.
422 */
423 bool
424 operator != (const Name &name) const { return !equals(name); }
Jeff Thompson82568ad2013-12-17 15:17:40 -0800425
426 /**
Jeff Thompsonafc45a92014-01-15 12:42:45 -0800427 * Return true if this is less than or equal to the other Name in the NDN canonical ordering.
428 * @param other The other Name to compare with.
429 *
430 * @see http://named-data.net/doc/0.2/technical/CanonicalOrder.html
Jeff Thompson82568ad2013-12-17 15:17:40 -0800431 */
Jeff Thompsonafc45a92014-01-15 12:42:45 -0800432 bool
433 operator <= (const Name& other) const { return compare(other) <= 0; }
434
435 /**
436 * Return true if this is less than the other Name in the NDN canonical ordering.
437 * @param other The other Name to compare with.
438 *
439 * @see http://named-data.net/doc/0.2/technical/CanonicalOrder.html
440 */
441 bool
442 operator < (const Name& other) const { return compare(other) < 0; }
443
444 /**
445 * Return true if this is less than or equal to the other Name in the NDN canonical ordering.
446 * @param other The other Name to compare with.
447 *
448 * @see http://named-data.net/doc/0.2/technical/CanonicalOrder.html
449 */
450 bool
451 operator >= (const Name& other) const { return compare(other) >= 0; }
452
453 /**
454 * Return true if this is greater than the other Name in the NDN canonical ordering.
455 * @param other The other Name to compare with.
456 *
457 * @see http://named-data.net/doc/0.2/technical/CanonicalOrder.html
458 */
459 bool
460 operator > (const Name& other) const { return compare(other) > 0; }
Jeff Thompson82568ad2013-12-17 15:17:40 -0800461
Jeff Thompsonec39fbd2013-10-04 10:56:23 -0700462 //
463 // Iterator interface to name components.
464 //
Jeff Thompsonec39fbd2013-10-04 10:56:23 -0700465
466 /**
467 * Begin iterator (const).
468 */
469 const_iterator
Alexander Afanasyev95e8c2f2014-02-06 17:29:30 -0800470 begin() const
471 {
472 return reinterpret_cast<const_iterator>(&*m_nameBlock.elements().begin());
473 }
Jeff Thompsonec39fbd2013-10-04 10:56:23 -0700474
475 /**
Jeff Thompsonec39fbd2013-10-04 10:56:23 -0700476 * End iterator (const).
Alexander Afanasyev95e8c2f2014-02-06 17:29:30 -0800477 *
478 * @todo Check if this crash when there are no elements in the buffer
Jeff Thompsonec39fbd2013-10-04 10:56:23 -0700479 */
480 const_iterator
Alexander Afanasyev29e5c3d2014-02-11 00:01:10 -0800481 end() const
482 {
483 return reinterpret_cast<const_iterator>(&*m_nameBlock.elements().end());
484 }
Jeff Thompsonec39fbd2013-10-04 10:56:23 -0700485
486 /**
Jeff Thompsonec39fbd2013-10-04 10:56:23 -0700487 * Reverse begin iterator (const).
488 */
489 const_reverse_iterator
Alexander Afanasyev29e5c3d2014-02-11 00:01:10 -0800490 rbegin() const
491 {
492 return const_reverse_iterator(end());
493 }
Jeff Thompsonec39fbd2013-10-04 10:56:23 -0700494
495 /**
496 * Reverse end iterator (const).
497 */
498 const_reverse_iterator
Alexander Afanasyev29e5c3d2014-02-11 00:01:10 -0800499 rend() const
500 {
501 return const_reverse_iterator(begin());
502 }
Jeff Thompsonec39fbd2013-10-04 10:56:23 -0700503
Jeff Thompson9c41dfe2013-06-27 12:10:25 -0700504private:
Alexander Afanasyev95e8c2f2014-02-06 17:29:30 -0800505 mutable Block m_nameBlock;
Alexander Afanasyevaf283d82014-01-03 13:23:34 -0800506};
507
508std::ostream &
509operator << (std::ostream &os, const Name &name);
510
511inline std::string
512Name::toUri() const
Jeff Thompson49e321a2013-10-04 17:35:59 -0700513{
Alexander Afanasyevaf283d82014-01-03 13:23:34 -0800514 std::ostringstream os;
515 os << *this;
516 return os.str();
Jeff Thompson49e321a2013-10-04 17:35:59 -0700517}
518
Alexander Afanasyev6d48bc12014-02-18 00:10:51 -0800519template<bool T>
520inline size_t
521Name::wireEncode(EncodingImpl<T>& blk) const
522{
523 size_t total_len = 0;
524
525 for (const_reverse_iterator i = rbegin ();
526 i != rend ();
527 ++i)
528 {
529 total_len += i->wireEncode (blk);
530 }
531
532 total_len += blk.prependVarNumber (total_len);
533 total_len += blk.prependVarNumber (Tlv::Name);
534 return total_len;
535}
536
Alexander Afanasyev52eb20d2014-02-06 18:25:54 -0800537inline const Block &
538Name::wireEncode() const
539{
540 if (m_nameBlock.hasWire())
541 return m_nameBlock;
542
Alexander Afanasyev380420b2014-02-09 20:52:29 -0800543 EncodingEstimator estimator;
544 size_t estimatedSize = wireEncode(estimator);
545
546 EncodingBuffer buffer(estimatedSize, 0);
547 wireEncode(buffer);
548
549 m_nameBlock = buffer.block();
550 m_nameBlock.parse();
551
Alexander Afanasyev52eb20d2014-02-06 18:25:54 -0800552 return m_nameBlock;
553}
554
555inline void
556Name::wireDecode(const Block &wire)
557{
Alexander Afanasyevc348f832014-02-17 16:35:17 -0800558 if (wire.type() != Tlv::Name)
559 throw Tlv::Error("Unexpected TLV type when decoding Name");
560
Alexander Afanasyev52eb20d2014-02-06 18:25:54 -0800561 m_nameBlock = wire;
562 m_nameBlock.parse();
563}
564
Alexander Afanasyev6d48bc12014-02-18 00:10:51 -0800565inline bool
566Name::hasWire() const
Alexander Afanasyev52eb20d2014-02-06 18:25:54 -0800567{
Alexander Afanasyev6d48bc12014-02-18 00:10:51 -0800568 return m_nameBlock.hasWire();
Alexander Afanasyev52eb20d2014-02-06 18:25:54 -0800569}
570
Alexander Afanasyev95e8c2f2014-02-06 17:29:30 -0800571} // namespace ndn
Jeff Thompson9c41dfe2013-06-27 12:10:25 -0700572
573#endif
574