Alexander Afanasyev | c169a81 | 2014-05-20 20:37:29 -0400 | [diff] [blame] | 1 | /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ |
Jeff Thompson | 47eecfc | 2013-07-07 22:56:46 -0700 | [diff] [blame] | 2 | /** |
Alexander Afanasyev | c169a81 | 2014-05-20 20:37:29 -0400 | [diff] [blame] | 3 | * Copyright (c) 2013-2014 Regents of the University of California. |
Alexander Afanasyev | dfa52c4 | 2014-04-24 21:10:11 -0700 | [diff] [blame] | 4 | * |
| 5 | * This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions). |
Alexander Afanasyev | dfa52c4 | 2014-04-24 21:10:11 -0700 | [diff] [blame] | 6 | * |
Alexander Afanasyev | c169a81 | 2014-05-20 20:37:29 -0400 | [diff] [blame] | 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. |
Alexander Afanasyev | dfa52c4 | 2014-04-24 21:10:11 -0700 | [diff] [blame] | 20 | * |
| 21 | * @author Jeff Thompson <jefft0@remap.ucla.edu> |
| 22 | * @author Alexander Afanasyev <http://lasr.cs.ucla.edu/afanasyev/index.html> |
| 23 | * @author Zhenkai Zhu <http://irl.cs.ucla.edu/~zhenkai/> |
Jeff Thompson | 9c41dfe | 2013-06-27 12:10:25 -0700 | [diff] [blame] | 24 | */ |
| 25 | |
| 26 | #ifndef NDN_NAME_HPP |
Jeff Thompson | 2d27e2f | 2013-08-09 12:55:00 -0700 | [diff] [blame] | 27 | #define NDN_NAME_HPP |
Jeff Thompson | 9c41dfe | 2013-06-27 12:10:25 -0700 | [diff] [blame] | 28 | |
Alexander Afanasyev | 95e8c2f | 2014-02-06 17:29:30 -0800 | [diff] [blame] | 29 | #include "common.hpp" |
| 30 | #include "name-component.hpp" |
Alexander Afanasyev | 258ec2b | 2014-05-14 16:15:37 -0700 | [diff] [blame] | 31 | #include "util/time.hpp" |
Alexander Afanasyev | 95e8c2f | 2014-02-06 17:29:30 -0800 | [diff] [blame] | 32 | |
Alexander Afanasyev | af283d8 | 2014-01-03 13:23:34 -0800 | [diff] [blame] | 33 | #include "encoding/block.hpp" |
Wentao Shang | 7794921 | 2014-02-01 23:42:24 -0800 | [diff] [blame] | 34 | #include "encoding/encoding-buffer.hpp" |
Jeff Thompson | 25b4e61 | 2013-10-10 16:03:24 -0700 | [diff] [blame] | 35 | |
Alexander Afanasyev | 95e8c2f | 2014-02-06 17:29:30 -0800 | [diff] [blame] | 36 | #include <boost/iterator/reverse_iterator.hpp> |
| 37 | |
Jeff Thompson | 9c41dfe | 2013-06-27 12:10:25 -0700 | [diff] [blame] | 38 | namespace ndn { |
Alexander Afanasyev | 95e8c2f | 2014-02-06 17:29:30 -0800 | [diff] [blame] | 39 | |
Jeff Thompson | c7d6550 | 2013-11-06 17:22:26 -0800 | [diff] [blame] | 40 | /** |
| 41 | * A Name holds an array of Name::Component and represents an NDN name. |
| 42 | */ |
Alexander Afanasyev | f73f063 | 2014-05-12 18:02:37 -0700 | [diff] [blame] | 43 | class Name : public enable_shared_from_this<Name> |
Alexander Afanasyev | 2a7f720 | 2014-04-23 14:25:29 -0700 | [diff] [blame] | 44 | { |
Jeff Thompson | 9c41dfe | 2013-06-27 12:10:25 -0700 | [diff] [blame] | 45 | public: |
Alexander Afanasyev | 2a7f720 | 2014-04-23 14:25:29 -0700 | [diff] [blame] | 46 | /// @brief Error that can be thrown from Name |
| 47 | class Error : public name::Component::Error |
| 48 | { |
Alexander Afanasyev | 1dd95c5 | 2014-03-22 19:11:36 -0700 | [diff] [blame] | 49 | public: |
Alexander Afanasyev | 2a7f720 | 2014-04-23 14:25:29 -0700 | [diff] [blame] | 50 | explicit |
Alexander Afanasyev | 1dd95c5 | 2014-03-22 19:11:36 -0700 | [diff] [blame] | 51 | Error(const std::string& what) |
Alexander Afanasyev | 2a7f720 | 2014-04-23 14:25:29 -0700 | [diff] [blame] | 52 | : name::Component::Error(what) |
| 53 | { |
| 54 | } |
Alexander Afanasyev | 1dd95c5 | 2014-03-22 19:11:36 -0700 | [diff] [blame] | 55 | }; |
Alexander Afanasyev | af283d8 | 2014-01-03 13:23:34 -0800 | [diff] [blame] | 56 | |
Alexander Afanasyev | 95e8c2f | 2014-02-06 17:29:30 -0800 | [diff] [blame] | 57 | typedef name::Component Component; |
| 58 | |
| 59 | typedef std::vector<Component> component_container; |
| 60 | |
| 61 | typedef Component value_type; |
| 62 | typedef void allocator_type; |
| 63 | typedef Component& reference; |
| 64 | typedef const Component const_reference; |
| 65 | typedef Component* pointer; |
| 66 | typedef const Component* const_pointer; |
| 67 | typedef Component* iterator; |
| 68 | typedef const Component* const_iterator; |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 69 | |
Alexander Afanasyev | 95e8c2f | 2014-02-06 17:29:30 -0800 | [diff] [blame] | 70 | typedef boost::reverse_iterator<iterator> reverse_iterator; |
| 71 | typedef boost::reverse_iterator<const_iterator> const_reverse_iterator; |
| 72 | |
| 73 | typedef component_container::difference_type difference_type; |
| 74 | typedef component_container::size_type size_type; |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 75 | |
Jeff Thompson | 443398d | 2013-07-02 19:45:46 -0700 | [diff] [blame] | 76 | /** |
| 77 | * Create a new Name with no components. |
| 78 | */ |
Alexander Afanasyev | 95e8c2f | 2014-02-06 17:29:30 -0800 | [diff] [blame] | 79 | Name() |
| 80 | : m_nameBlock(Tlv::Name) |
| 81 | { |
Jeff Thompson | 016ed64 | 2013-07-02 14:39:06 -0700 | [diff] [blame] | 82 | } |
Alexander Afanasyev | 52eb20d | 2014-02-06 18:25:54 -0800 | [diff] [blame] | 83 | |
| 84 | /** |
| 85 | * @brief Create Name object from wire block |
| 86 | * |
| 87 | * This is a more efficient equivalent for |
| 88 | * @code |
| 89 | * Name name; |
| 90 | * name.wireDecode(wire); |
| 91 | * @endcode |
| 92 | */ |
Alexander Afanasyev | 6d48bc1 | 2014-02-18 00:10:51 -0800 | [diff] [blame] | 93 | explicit |
Alexander Afanasyev | 1dd95c5 | 2014-03-22 19:11:36 -0700 | [diff] [blame] | 94 | Name(const Block& wire) |
Alexander Afanasyev | 52eb20d | 2014-02-06 18:25:54 -0800 | [diff] [blame] | 95 | { |
| 96 | m_nameBlock = wire; |
| 97 | m_nameBlock.parse(); |
| 98 | } |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 99 | |
Jeff Thompson | 3f2175b | 2013-07-31 17:12:47 -0700 | [diff] [blame] | 100 | /** |
Jeff Thompson | 443398d | 2013-07-02 19:45:46 -0700 | [diff] [blame] | 101 | * Parse the uri according to the NDN URI Scheme and create the name with the components. |
Jeff Thompson | 3f2175b | 2013-07-31 17:12:47 -0700 | [diff] [blame] | 102 | * @param uri The URI string. |
Jeff Thompson | 443398d | 2013-07-02 19:45:46 -0700 | [diff] [blame] | 103 | */ |
Jeff Thompson | 3549ef3 | 2013-09-25 14:05:17 -0700 | [diff] [blame] | 104 | Name(const char* uri) |
Jeff Thompson | 67515bd | 2013-08-15 17:43:22 -0700 | [diff] [blame] | 105 | { |
| 106 | set(uri); |
| 107 | } |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 108 | |
Jeff Thompson | e5f839b | 2013-06-28 12:50:38 -0700 | [diff] [blame] | 109 | /** |
Jeff Thompson | 3549ef3 | 2013-09-25 14:05:17 -0700 | [diff] [blame] | 110 | * Parse the uri according to the NDN URI Scheme and create the name with the components. |
| 111 | * @param uri The URI string. |
| 112 | */ |
| 113 | Name(const std::string& uri) |
| 114 | { |
| 115 | set(uri.c_str()); |
| 116 | } |
Jeff Thompson | ec39fbd | 2013-10-04 10:56:23 -0700 | [diff] [blame] | 117 | |
Alexander Afanasyev | 380420b | 2014-02-09 20:52:29 -0800 | [diff] [blame] | 118 | /** |
| 119 | * @brief Fast encoding or block size estimation |
| 120 | */ |
| 121 | template<bool T> |
Wentao Shang | 7794921 | 2014-02-01 23:42:24 -0800 | [diff] [blame] | 122 | size_t |
Alexander Afanasyev | 1dd95c5 | 2014-03-22 19:11:36 -0700 | [diff] [blame] | 123 | wireEncode(EncodingImpl<T>& block) const; |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 124 | |
Alexander Afanasyev | 1dd95c5 | 2014-03-22 19:11:36 -0700 | [diff] [blame] | 125 | const Block& |
Alexander Afanasyev | af283d8 | 2014-01-03 13:23:34 -0800 | [diff] [blame] | 126 | wireEncode() const; |
Alexander Afanasyev | 848c61a | 2014-01-03 13:52:04 -0800 | [diff] [blame] | 127 | |
| 128 | void |
Alexander Afanasyev | 1dd95c5 | 2014-03-22 19:11:36 -0700 | [diff] [blame] | 129 | wireDecode(const Block& wire); |
Alexander Afanasyev | 6d48bc1 | 2014-02-18 00:10:51 -0800 | [diff] [blame] | 130 | |
| 131 | /** |
| 132 | * @brief Check if already has wire |
| 133 | */ |
| 134 | bool |
| 135 | hasWire() const; |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 136 | |
Jeff Thompson | b468c31 | 2013-07-01 17:50:14 -0700 | [diff] [blame] | 137 | /** |
Jeff Thompson | 67515bd | 2013-08-15 17:43:22 -0700 | [diff] [blame] | 138 | * Parse the uri according to the NDN URI Scheme and set the name with the components. |
Jeff Thompson | 7781b39 | 2013-12-17 11:45:59 -0800 | [diff] [blame] | 139 | * @param uri The null-terminated URI string. |
Jeff Thompson | 67515bd | 2013-08-15 17:43:22 -0700 | [diff] [blame] | 140 | */ |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 141 | void |
Alexander Afanasyev | fdbfc6d | 2014-04-14 15:12:11 -0700 | [diff] [blame] | 142 | set(const char* uri); |
Jeff Thompson | 67515bd | 2013-08-15 17:43:22 -0700 | [diff] [blame] | 143 | |
| 144 | /** |
Jeff Thompson | 7781b39 | 2013-12-17 11:45:59 -0800 | [diff] [blame] | 145 | * Parse the uri according to the NDN URI Scheme and set the name with the components. |
| 146 | * @param uri The URI string. |
| 147 | */ |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 148 | void |
Alexander Afanasyev | 95e8c2f | 2014-02-06 17:29:30 -0800 | [diff] [blame] | 149 | set(const std::string& uri) |
| 150 | { |
| 151 | set(uri.c_str()); |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 152 | } |
| 153 | |
Jeff Thompson | 7781b39 | 2013-12-17 11:45:59 -0800 | [diff] [blame] | 154 | /** |
Jeff Thompson | 0aa66f2 | 2013-09-23 13:02:13 -0700 | [diff] [blame] | 155 | * Append a new component, copying from value of length valueLength. |
Jeff Thompson | 26b0d79 | 2013-09-23 16:19:01 -0700 | [diff] [blame] | 156 | * @return This name so that you can chain calls to append. |
Jeff Thompson | e5f839b | 2013-06-28 12:50:38 -0700 | [diff] [blame] | 157 | */ |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 158 | Name& |
Alexander Afanasyev | 1dd95c5 | 2014-03-22 19:11:36 -0700 | [diff] [blame] | 159 | append(const uint8_t* value, size_t valueLength) |
Jeff Thompson | 0f74345 | 2013-09-12 14:23:18 -0700 | [diff] [blame] | 160 | { |
Alexander Afanasyev | 29e5c3d | 2014-02-11 00:01:10 -0800 | [diff] [blame] | 161 | m_nameBlock.push_back(Component(value, valueLength)); |
Jeff Thompson | 26b0d79 | 2013-09-23 16:19:01 -0700 | [diff] [blame] | 162 | return *this; |
Jeff Thompson | e5f839b | 2013-06-28 12:50:38 -0700 | [diff] [blame] | 163 | } |
Jeff Thompson | f72b1ac | 2013-08-16 16:44:41 -0700 | [diff] [blame] | 164 | |
Alexander Afanasyev | bf9671d | 2014-02-11 13:44:13 -0800 | [diff] [blame] | 165 | /** |
| 166 | * Append a new component, copying from value of length valueLength. |
| 167 | * @return This name so that you can chain calls to append. |
| 168 | */ |
| 169 | template<class InputIterator> |
| 170 | Name& |
| 171 | append(InputIterator begin, InputIterator end) |
| 172 | { |
| 173 | m_nameBlock.push_back(Component(begin, end)); |
| 174 | return *this; |
| 175 | } |
| 176 | |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 177 | Name& |
Alexander Afanasyev | 1dd95c5 | 2014-03-22 19:11:36 -0700 | [diff] [blame] | 178 | append(const ConstBufferPtr& value) |
Jeff Thompson | 0f74345 | 2013-09-12 14:23:18 -0700 | [diff] [blame] | 179 | { |
Alexander Afanasyev | 29e5c3d | 2014-02-11 00:01:10 -0800 | [diff] [blame] | 180 | m_nameBlock.push_back(value); |
Jeff Thompson | 26b0d79 | 2013-09-23 16:19:01 -0700 | [diff] [blame] | 181 | return *this; |
Jeff Thompson | f72b1ac | 2013-08-16 16:44:41 -0700 | [diff] [blame] | 182 | } |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 183 | |
| 184 | Name& |
Alexander Afanasyev | 1dd95c5 | 2014-03-22 19:11:36 -0700 | [diff] [blame] | 185 | append(const Component& value) |
Jeff Thompson | 21eb721 | 2013-09-26 09:05:40 -0700 | [diff] [blame] | 186 | { |
Alexander Afanasyev | 29e5c3d | 2014-02-11 00:01:10 -0800 | [diff] [blame] | 187 | m_nameBlock.push_back(value); |
Jeff Thompson | 21eb721 | 2013-09-26 09:05:40 -0700 | [diff] [blame] | 188 | return *this; |
| 189 | } |
Alexander Afanasyev | af283d8 | 2014-01-03 13:23:34 -0800 | [diff] [blame] | 190 | |
Alexander Afanasyev | 594cdb2 | 2014-01-03 15:11:33 -0800 | [diff] [blame] | 191 | /** |
| 192 | * @brief Append name component that represented as a string |
| 193 | * |
| 194 | * Note that this method is necessary to ensure correctness and unambiguity of |
| 195 | * ``append("string")`` operations (both Component and Name can be implicitly |
| 196 | * converted from string, each having different outcomes |
| 197 | */ |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 198 | Name& |
Alexander Afanasyev | 1dd95c5 | 2014-03-22 19:11:36 -0700 | [diff] [blame] | 199 | append(const char* value) |
Alexander Afanasyev | 594cdb2 | 2014-01-03 15:11:33 -0800 | [diff] [blame] | 200 | { |
Alexander Afanasyev | 29e5c3d | 2014-02-11 00:01:10 -0800 | [diff] [blame] | 201 | m_nameBlock.push_back(Component(value)); |
Alexander Afanasyev | 594cdb2 | 2014-01-03 15:11:33 -0800 | [diff] [blame] | 202 | return *this; |
| 203 | } |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 204 | |
Alexander Afanasyev | af283d8 | 2014-01-03 13:23:34 -0800 | [diff] [blame] | 205 | Name& |
Alexander Afanasyev | 1dd95c5 | 2014-03-22 19:11:36 -0700 | [diff] [blame] | 206 | append(const Block& value) |
Alexander Afanasyev | af283d8 | 2014-01-03 13:23:34 -0800 | [diff] [blame] | 207 | { |
Alexander Afanasyev | 380420b | 2014-02-09 20:52:29 -0800 | [diff] [blame] | 208 | if (value.type() == Tlv::NameComponent) |
Alexander Afanasyev | 29e5c3d | 2014-02-11 00:01:10 -0800 | [diff] [blame] | 209 | m_nameBlock.push_back(value); |
Alexander Afanasyev | 380420b | 2014-02-09 20:52:29 -0800 | [diff] [blame] | 210 | else |
Alexander Afanasyev | 29e5c3d | 2014-02-11 00:01:10 -0800 | [diff] [blame] | 211 | m_nameBlock.push_back(Block(Tlv::NameComponent, value)); |
Alexander Afanasyev | 380420b | 2014-02-09 20:52:29 -0800 | [diff] [blame] | 212 | |
Alexander Afanasyev | af283d8 | 2014-01-03 13:23:34 -0800 | [diff] [blame] | 213 | return *this; |
| 214 | } |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 215 | |
Jeff Thompson | e5f839b | 2013-06-28 12:50:38 -0700 | [diff] [blame] | 216 | /** |
Jeff Thompson | 26b0d79 | 2013-09-23 16:19:01 -0700 | [diff] [blame] | 217 | * Append the components of the given name to this name. |
| 218 | * @param name The Name with components to append. |
| 219 | * @return This name so that you can chain calls to append. |
Jeff Thompson | 0aa66f2 | 2013-09-23 13:02:13 -0700 | [diff] [blame] | 220 | */ |
Jeff Thompson | 26b0d79 | 2013-09-23 16:19:01 -0700 | [diff] [blame] | 221 | Name& |
| 222 | append(const Name& name); |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 223 | |
Jeff Thompson | 0aa66f2 | 2013-09-23 13:02:13 -0700 | [diff] [blame] | 224 | /** |
Jeff Thompson | e5f839b | 2013-06-28 12:50:38 -0700 | [diff] [blame] | 225 | * Clear all the components. |
| 226 | */ |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 227 | void |
Alexander Afanasyev | 95e8c2f | 2014-02-06 17:29:30 -0800 | [diff] [blame] | 228 | clear() |
| 229 | { |
| 230 | m_nameBlock = Block(Tlv::Name); |
Jeff Thompson | e5f839b | 2013-06-28 12:50:38 -0700 | [diff] [blame] | 231 | } |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 232 | |
Jeff Thompson | e5f839b | 2013-06-28 12:50:38 -0700 | [diff] [blame] | 233 | /** |
Jeff Thompson | d0159d7 | 2013-09-23 13:34:15 -0700 | [diff] [blame] | 234 | * Get a new name, constructed as a subset of components. |
| 235 | * @param iStartComponent The index if the first component to get. |
| 236 | * @param nComponents The number of components starting at iStartComponent. |
| 237 | * @return A new name. |
| 238 | */ |
| 239 | Name |
| 240 | getSubName(size_t iStartComponent, size_t nComponents) const; |
| 241 | |
| 242 | /** |
| 243 | * Get a new name, constructed as a subset of components starting at iStartComponent until the end of the name. |
| 244 | * @param iStartComponent The index if the first component to get. |
| 245 | * @return A new name. |
| 246 | */ |
| 247 | Name |
| 248 | getSubName(size_t iStartComponent) const; |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 249 | |
Jeff Thompson | d0159d7 | 2013-09-23 13:34:15 -0700 | [diff] [blame] | 250 | /** |
| 251 | * Return a new Name with the first nComponents components of this Name. |
Jeff Thompson | eb0358f | 2013-12-17 10:59:53 -0800 | [diff] [blame] | 252 | * @param nComponents The number of prefix components. If nComponents is -N then return the prefix up |
| 253 | * to name.size() - N. For example getPrefix(-1) returns the name without the final component. |
Jeff Thompson | d0159d7 | 2013-09-23 13:34:15 -0700 | [diff] [blame] | 254 | * @return A new Name. |
| 255 | */ |
| 256 | Name |
Jeff Thompson | eb0358f | 2013-12-17 10:59:53 -0800 | [diff] [blame] | 257 | getPrefix(int nComponents) const |
Jeff Thompson | d0159d7 | 2013-09-23 13:34:15 -0700 | [diff] [blame] | 258 | { |
Jeff Thompson | eb0358f | 2013-12-17 10:59:53 -0800 | [diff] [blame] | 259 | if (nComponents < 0) |
Alexander Afanasyev | 29e5c3d | 2014-02-11 00:01:10 -0800 | [diff] [blame] | 260 | return getSubName(0, m_nameBlock.elements_size() + nComponents); |
Jeff Thompson | eb0358f | 2013-12-17 10:59:53 -0800 | [diff] [blame] | 261 | else |
| 262 | return getSubName(0, nComponents); |
Jeff Thompson | d0159d7 | 2013-09-23 13:34:15 -0700 | [diff] [blame] | 263 | } |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 264 | |
Jeff Thompson | d0159d7 | 2013-09-23 13:34:15 -0700 | [diff] [blame] | 265 | /** |
Jeff Thompson | e606351 | 2013-07-01 15:11:28 -0700 | [diff] [blame] | 266 | * Encode this name as a URI. |
Jeff Thompson | 3f2175b | 2013-07-31 17:12:47 -0700 | [diff] [blame] | 267 | * @return The encoded URI. |
Jeff Thompson | e606351 | 2013-07-01 15:11:28 -0700 | [diff] [blame] | 268 | */ |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 269 | std::string |
Jeff Thompson | 0050abe | 2013-09-17 12:50:25 -0700 | [diff] [blame] | 270 | toUri() const; |
Jeff Thompson | d129ac1 | 2013-10-11 14:30:12 -0700 | [diff] [blame] | 271 | |
| 272 | /** |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 273 | * @brief Append a component with the number encoded as nonNegativeInteger |
| 274 | * |
| 275 | * @see http://named-data.net/doc/ndn-tlv/tlv.html#non-negative-integer-encoding |
| 276 | * |
Steve DiBenedetto | c145d49 | 2014-03-11 16:35:45 -0600 | [diff] [blame] | 277 | * @param number The non-negative number |
| 278 | * @return This name so that you can chain calls to append. |
| 279 | */ |
| 280 | Name& |
| 281 | appendNumber(uint64_t number) |
| 282 | { |
| 283 | m_nameBlock.push_back(Component::fromNumber(number)); |
| 284 | return *this; |
| 285 | } |
| 286 | |
Jeff Thompson | ec7789a | 2013-08-21 11:08:36 -0700 | [diff] [blame] | 287 | /** |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 288 | * @brief An alias for appendNumber(uint64_t) |
| 289 | */ |
| 290 | Name& |
| 291 | appendVersion(uint64_t number) |
| 292 | { |
| 293 | return appendNumber(number); |
| 294 | } |
| 295 | |
| 296 | /** |
| 297 | * @brief Append a component with the encoded version number (current UNIX timestamp |
| 298 | * in milliseconds) |
| 299 | */ |
| 300 | Name& |
| 301 | appendVersion(); |
| 302 | |
| 303 | /** |
| 304 | * @brief An alias for appendNumber(uint64_t) |
| 305 | */ |
| 306 | Name& |
| 307 | appendSegment(uint64_t number) |
| 308 | { |
| 309 | return appendNumber(number); |
| 310 | } |
| 311 | |
| 312 | /** |
Jeff Thompson | 3c2ab01 | 2013-10-02 14:18:16 -0700 | [diff] [blame] | 313 | * Check if this name has the same component count and components as the given name. |
| 314 | * @param name The Name to check. |
| 315 | * @return true if the names are equal, otherwise false. |
| 316 | */ |
| 317 | bool |
| 318 | equals(const Name& name) const; |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 319 | |
Jeff Thompson | 3c2ab01 | 2013-10-02 14:18:16 -0700 | [diff] [blame] | 320 | /** |
Jeff Thompson | ec7789a | 2013-08-21 11:08:36 -0700 | [diff] [blame] | 321 | * Check if the N components of this name are the same as the first N components of the given name. |
| 322 | * @param name The Name to check. |
| 323 | * @return true if this matches the given name, otherwise false. This always returns true if this name is empty. |
| 324 | */ |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 325 | bool |
Alexander Afanasyev | af283d8 | 2014-01-03 13:23:34 -0800 | [diff] [blame] | 326 | isPrefixOf(const Name& name) const; |
| 327 | |
Jeff Thompson | ec39fbd | 2013-10-04 10:56:23 -0700 | [diff] [blame] | 328 | // |
| 329 | // vector equivalent interface. |
| 330 | // |
Alexander Afanasyev | af283d8 | 2014-01-03 13:23:34 -0800 | [diff] [blame] | 331 | |
| 332 | /** |
| 333 | * @brief Check if name is emtpy |
| 334 | */ |
| 335 | bool |
Alexander Afanasyev | fdbfc6d | 2014-04-14 15:12:11 -0700 | [diff] [blame] | 336 | empty() const |
| 337 | { |
| 338 | return m_nameBlock.elements().empty(); |
| 339 | } |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 340 | |
Jeff Thompson | ec39fbd | 2013-10-04 10:56:23 -0700 | [diff] [blame] | 341 | /** |
| 342 | * Get the number of components. |
| 343 | * @return The number of components. |
| 344 | */ |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 345 | size_t |
Alexander Afanasyev | fdbfc6d | 2014-04-14 15:12:11 -0700 | [diff] [blame] | 346 | size() const |
| 347 | { |
| 348 | return m_nameBlock.elements_size(); |
| 349 | } |
Jeff Thompson | ec39fbd | 2013-10-04 10:56:23 -0700 | [diff] [blame] | 350 | |
| 351 | /** |
| 352 | * Get the component at the given index. |
| 353 | * @param i The index of the component, starting from 0. |
| 354 | * @return The name component at the index. |
| 355 | */ |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 356 | const Component& |
Alexander Afanasyev | 8f9aa8bed | 2013-12-30 15:58:57 -0800 | [diff] [blame] | 357 | get(ssize_t i) const |
| 358 | { |
| 359 | if (i >= 0) |
Alexander Afanasyev | 95e8c2f | 2014-02-06 17:29:30 -0800 | [diff] [blame] | 360 | return reinterpret_cast<const Component&>(m_nameBlock.elements()[i]); |
Alexander Afanasyev | 8f9aa8bed | 2013-12-30 15:58:57 -0800 | [diff] [blame] | 361 | else |
Alexander Afanasyev | 95e8c2f | 2014-02-06 17:29:30 -0800 | [diff] [blame] | 362 | return reinterpret_cast<const Component&>(m_nameBlock.elements()[size() + i]); |
| 363 | } |
| 364 | |
| 365 | const Component& |
Alexander Afanasyev | 1dd95c5 | 2014-03-22 19:11:36 -0700 | [diff] [blame] | 366 | operator[](ssize_t i) const |
Alexander Afanasyev | 95e8c2f | 2014-02-06 17:29:30 -0800 | [diff] [blame] | 367 | { |
| 368 | return get(i); |
Alexander Afanasyev | 8f9aa8bed | 2013-12-30 15:58:57 -0800 | [diff] [blame] | 369 | } |
Alexander Afanasyev | c234429 | 2014-03-02 00:08:00 +0000 | [diff] [blame] | 370 | |
| 371 | /** |
| 372 | * @brief Get component at the specified index |
| 373 | * |
| 374 | * Unlike get() and operator[] methods, at() checks for out of bounds |
| 375 | * and will throw Name::Error when it happens |
| 376 | * |
| 377 | * @throws Name::Error if index out of bounds |
| 378 | */ |
Alexander Afanasyev | 95e8c2f | 2014-02-06 17:29:30 -0800 | [diff] [blame] | 379 | const Component& |
| 380 | at(ssize_t i) const |
| 381 | { |
Alexander Afanasyev | 1dd95c5 | 2014-03-22 19:11:36 -0700 | [diff] [blame] | 382 | if ((i >= 0 && static_cast<size_t>(i) >= size()) || |
| 383 | (i < 0 && static_cast<size_t>(-i) > size())) |
Alexander Afanasyev | c234429 | 2014-03-02 00:08:00 +0000 | [diff] [blame] | 384 | throw Error("Requested component does not exist (out of bounds)"); |
| 385 | |
Alexander Afanasyev | 95e8c2f | 2014-02-06 17:29:30 -0800 | [diff] [blame] | 386 | return get(i); |
| 387 | } |
| 388 | |
Jeff Thompson | afc45a9 | 2014-01-15 12:42:45 -0800 | [diff] [blame] | 389 | /** |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 390 | * @brief Compare this to the other Name using NDN canonical ordering. |
Jeff Thompson | afc45a9 | 2014-01-15 12:42:45 -0800 | [diff] [blame] | 391 | * |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 392 | * If the first components of each name are not equal, this returns -1 if the first comes |
| 393 | * before the second using the NDN canonical ordering for name components, or 1 if it |
| 394 | * comes after. If they are equal, this compares the second components of each name, etc. |
| 395 | * If both names are the same up to the size of the shorter name, this returns -1 if the |
| 396 | * first name is shorter than the second or 1 if it is longer. For example, if you |
| 397 | * std::sort gives: /a/b/d /a/b/cc /c /c/a /bb . This is intuitive because all names with |
| 398 | * the prefix /a are next to each other. But it may be also be counter-intuitive because |
| 399 | * /c comes before /bb according to NDN canonical ordering since it is shorter. @param |
| 400 | * other The other Name to compare with. @return 0 If they compare equal, -1 if *this |
| 401 | * comes before other in the canonical ordering, or 1 if *this comes after other in the |
| 402 | * canonical ordering. |
| 403 | * |
| 404 | * @see http://named-data.net/doc/ndn-tlv/name.html#canonical-order |
Jeff Thompson | afc45a9 | 2014-01-15 12:42:45 -0800 | [diff] [blame] | 405 | */ |
| 406 | int |
| 407 | compare(const Name& other) const; |
Jeff Thompson | ec39fbd | 2013-10-04 10:56:23 -0700 | [diff] [blame] | 408 | |
Jeff Thompson | ec39fbd | 2013-10-04 10:56:23 -0700 | [diff] [blame] | 409 | /** |
| 410 | * Append the component |
| 411 | * @param component The component of type T. |
| 412 | */ |
| 413 | template<class T> void |
Alexander Afanasyev | 1dd95c5 | 2014-03-22 19:11:36 -0700 | [diff] [blame] | 414 | push_back(const T& component) |
Jeff Thompson | ec39fbd | 2013-10-04 10:56:23 -0700 | [diff] [blame] | 415 | { |
| 416 | append(component); |
| 417 | } |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 418 | |
Jeff Thompson | 91737f5 | 2013-10-04 11:07:24 -0700 | [diff] [blame] | 419 | /** |
| 420 | * Check if this name has the same component count and components as the given name. |
| 421 | * @param name The Name to check. |
| 422 | * @return true if the names are equal, otherwise false. |
| 423 | */ |
| 424 | bool |
Alexander Afanasyev | fdbfc6d | 2014-04-14 15:12:11 -0700 | [diff] [blame] | 425 | operator==(const Name& name) const |
| 426 | { |
| 427 | return equals(name); |
| 428 | } |
Jeff Thompson | 91737f5 | 2013-10-04 11:07:24 -0700 | [diff] [blame] | 429 | |
| 430 | /** |
| 431 | * Check if this name has the same component count and components as the given name. |
| 432 | * @param name The Name to check. |
| 433 | * @return true if the names are not equal, otherwise false. |
| 434 | */ |
| 435 | bool |
Alexander Afanasyev | fdbfc6d | 2014-04-14 15:12:11 -0700 | [diff] [blame] | 436 | operator!=(const Name& name) const |
| 437 | { |
| 438 | return !equals(name); |
| 439 | } |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 440 | |
Jeff Thompson | 82568ad | 2013-12-17 15:17:40 -0800 | [diff] [blame] | 441 | /** |
Jeff Thompson | afc45a9 | 2014-01-15 12:42:45 -0800 | [diff] [blame] | 442 | * Return true if this is less than or equal to the other Name in the NDN canonical ordering. |
| 443 | * @param other The other Name to compare with. |
| 444 | * |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 445 | * @see http://named-data.net/doc/ndn-tlv/name.html#canonical-order |
Jeff Thompson | 82568ad | 2013-12-17 15:17:40 -0800 | [diff] [blame] | 446 | */ |
Jeff Thompson | afc45a9 | 2014-01-15 12:42:45 -0800 | [diff] [blame] | 447 | bool |
Alexander Afanasyev | fdbfc6d | 2014-04-14 15:12:11 -0700 | [diff] [blame] | 448 | operator<=(const Name& other) const |
| 449 | { |
| 450 | return compare(other) <= 0; |
| 451 | } |
Jeff Thompson | afc45a9 | 2014-01-15 12:42:45 -0800 | [diff] [blame] | 452 | |
| 453 | /** |
| 454 | * Return true if this is less than the other Name in the NDN canonical ordering. |
| 455 | * @param other The other Name to compare with. |
| 456 | * |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 457 | * @see http://named-data.net/doc/ndn-tlv/name.html#canonical-order |
Jeff Thompson | afc45a9 | 2014-01-15 12:42:45 -0800 | [diff] [blame] | 458 | */ |
| 459 | bool |
Alexander Afanasyev | fdbfc6d | 2014-04-14 15:12:11 -0700 | [diff] [blame] | 460 | operator<(const Name& other) const |
| 461 | { |
| 462 | return compare(other) < 0; |
| 463 | } |
Jeff Thompson | afc45a9 | 2014-01-15 12:42:45 -0800 | [diff] [blame] | 464 | |
| 465 | /** |
| 466 | * Return true if this is less than or equal to the other Name in the NDN canonical ordering. |
| 467 | * @param other The other Name to compare with. |
| 468 | * |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 469 | * @see http://named-data.net/doc/ndn-tlv/name.html#canonical-order |
Jeff Thompson | afc45a9 | 2014-01-15 12:42:45 -0800 | [diff] [blame] | 470 | */ |
| 471 | bool |
Alexander Afanasyev | fdbfc6d | 2014-04-14 15:12:11 -0700 | [diff] [blame] | 472 | operator>=(const Name& other) const |
| 473 | { |
| 474 | return compare(other) >= 0; |
| 475 | } |
Jeff Thompson | afc45a9 | 2014-01-15 12:42:45 -0800 | [diff] [blame] | 476 | |
| 477 | /** |
| 478 | * Return true if this is greater than the other Name in the NDN canonical ordering. |
| 479 | * @param other The other Name to compare with. |
| 480 | * |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 481 | * @see http://named-data.net/doc/ndn-tlv/name.html#canonical-order |
Jeff Thompson | afc45a9 | 2014-01-15 12:42:45 -0800 | [diff] [blame] | 482 | */ |
| 483 | bool |
Alexander Afanasyev | fdbfc6d | 2014-04-14 15:12:11 -0700 | [diff] [blame] | 484 | operator>(const Name& other) const |
| 485 | { |
| 486 | return compare(other) > 0; |
| 487 | } |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 488 | |
Jeff Thompson | ec39fbd | 2013-10-04 10:56:23 -0700 | [diff] [blame] | 489 | // |
| 490 | // Iterator interface to name components. |
| 491 | // |
Jeff Thompson | ec39fbd | 2013-10-04 10:56:23 -0700 | [diff] [blame] | 492 | |
| 493 | /** |
| 494 | * Begin iterator (const). |
| 495 | */ |
| 496 | const_iterator |
Alexander Afanasyev | 95e8c2f | 2014-02-06 17:29:30 -0800 | [diff] [blame] | 497 | begin() const |
| 498 | { |
| 499 | return reinterpret_cast<const_iterator>(&*m_nameBlock.elements().begin()); |
| 500 | } |
Jeff Thompson | ec39fbd | 2013-10-04 10:56:23 -0700 | [diff] [blame] | 501 | |
| 502 | /** |
Jeff Thompson | ec39fbd | 2013-10-04 10:56:23 -0700 | [diff] [blame] | 503 | * End iterator (const). |
Alexander Afanasyev | 95e8c2f | 2014-02-06 17:29:30 -0800 | [diff] [blame] | 504 | * |
| 505 | * @todo Check if this crash when there are no elements in the buffer |
Jeff Thompson | ec39fbd | 2013-10-04 10:56:23 -0700 | [diff] [blame] | 506 | */ |
| 507 | const_iterator |
Alexander Afanasyev | 29e5c3d | 2014-02-11 00:01:10 -0800 | [diff] [blame] | 508 | end() const |
| 509 | { |
| 510 | return reinterpret_cast<const_iterator>(&*m_nameBlock.elements().end()); |
| 511 | } |
Jeff Thompson | ec39fbd | 2013-10-04 10:56:23 -0700 | [diff] [blame] | 512 | |
| 513 | /** |
Jeff Thompson | ec39fbd | 2013-10-04 10:56:23 -0700 | [diff] [blame] | 514 | * Reverse begin iterator (const). |
| 515 | */ |
| 516 | const_reverse_iterator |
Alexander Afanasyev | 29e5c3d | 2014-02-11 00:01:10 -0800 | [diff] [blame] | 517 | rbegin() const |
| 518 | { |
| 519 | return const_reverse_iterator(end()); |
| 520 | } |
Jeff Thompson | ec39fbd | 2013-10-04 10:56:23 -0700 | [diff] [blame] | 521 | |
| 522 | /** |
| 523 | * Reverse end iterator (const). |
| 524 | */ |
| 525 | const_reverse_iterator |
Alexander Afanasyev | 29e5c3d | 2014-02-11 00:01:10 -0800 | [diff] [blame] | 526 | rend() const |
| 527 | { |
| 528 | return const_reverse_iterator(begin()); |
| 529 | } |
Jeff Thompson | ec39fbd | 2013-10-04 10:56:23 -0700 | [diff] [blame] | 530 | |
Jeff Thompson | 9c41dfe | 2013-06-27 12:10:25 -0700 | [diff] [blame] | 531 | private: |
Alexander Afanasyev | 95e8c2f | 2014-02-06 17:29:30 -0800 | [diff] [blame] | 532 | mutable Block m_nameBlock; |
Alexander Afanasyev | af283d8 | 2014-01-03 13:23:34 -0800 | [diff] [blame] | 533 | }; |
| 534 | |
Alexander Afanasyev | 1dd95c5 | 2014-03-22 19:11:36 -0700 | [diff] [blame] | 535 | inline std::ostream& |
| 536 | operator<<(std::ostream& os, const Name& name) |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 537 | { |
Alexander Afanasyev | 1dd95c5 | 2014-03-22 19:11:36 -0700 | [diff] [blame] | 538 | if (name.empty()) |
| 539 | { |
| 540 | os << "/"; |
| 541 | } |
| 542 | else |
| 543 | { |
| 544 | for (Name::const_iterator i = name.begin(); i != name.end(); i++) { |
| 545 | os << "/"; |
Alexander Afanasyev | 9c57818 | 2014-05-14 17:28:28 -0700 | [diff] [blame] | 546 | i->toUri(os); |
Alexander Afanasyev | 1dd95c5 | 2014-03-22 19:11:36 -0700 | [diff] [blame] | 547 | } |
| 548 | } |
| 549 | return os; |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 550 | } |
| 551 | |
| 552 | inline std::string |
Alexander Afanasyev | af283d8 | 2014-01-03 13:23:34 -0800 | [diff] [blame] | 553 | Name::toUri() const |
Jeff Thompson | 49e321a | 2013-10-04 17:35:59 -0700 | [diff] [blame] | 554 | { |
Alexander Afanasyev | af283d8 | 2014-01-03 13:23:34 -0800 | [diff] [blame] | 555 | std::ostringstream os; |
| 556 | os << *this; |
| 557 | return os.str(); |
Jeff Thompson | 49e321a | 2013-10-04 17:35:59 -0700 | [diff] [blame] | 558 | } |
| 559 | |
Alexander Afanasyev | 0df2836 | 2014-03-20 17:31:43 -0700 | [diff] [blame] | 560 | inline std::istream& |
| 561 | operator>>(std::istream& is, Name& name) |
| 562 | { |
| 563 | std::string inputString; |
| 564 | is >> inputString; |
| 565 | name.set(inputString); |
| 566 | |
| 567 | return is; |
| 568 | } |
| 569 | |
Alexander Afanasyev | 1dd95c5 | 2014-03-22 19:11:36 -0700 | [diff] [blame] | 570 | |
| 571 | inline void |
| 572 | Name::set(const char* uri_cstr) |
| 573 | { |
| 574 | clear(); |
| 575 | |
| 576 | std::string uri = uri_cstr; |
| 577 | trim(uri); |
| 578 | if (uri.size() == 0) |
| 579 | return; |
| 580 | |
| 581 | size_t iColon = uri.find(':'); |
| 582 | if (iColon != std::string::npos) { |
| 583 | // Make sure the colon came before a '/'. |
| 584 | size_t iFirstSlash = uri.find('/'); |
| 585 | if (iFirstSlash == std::string::npos || iColon < iFirstSlash) { |
| 586 | // Omit the leading protocol such as ndn: |
| 587 | uri.erase(0, iColon + 1); |
| 588 | trim(uri); |
| 589 | } |
| 590 | } |
| 591 | |
| 592 | // Trim the leading slash and possibly the authority. |
| 593 | if (uri[0] == '/') { |
| 594 | if (uri.size() >= 2 && uri[1] == '/') { |
| 595 | // Strip the authority following "//". |
| 596 | size_t iAfterAuthority = uri.find('/', 2); |
| 597 | if (iAfterAuthority == std::string::npos) |
| 598 | // Unusual case: there was only an authority. |
| 599 | return; |
| 600 | else { |
| 601 | uri.erase(0, iAfterAuthority + 1); |
| 602 | trim(uri); |
| 603 | } |
| 604 | } |
| 605 | else { |
| 606 | uri.erase(0, 1); |
| 607 | trim(uri); |
| 608 | } |
| 609 | } |
| 610 | |
| 611 | size_t iComponentStart = 0; |
| 612 | |
| 613 | // Unescape the components. |
| 614 | while (iComponentStart < uri.size()) { |
| 615 | size_t iComponentEnd = uri.find("/", iComponentStart); |
| 616 | if (iComponentEnd == std::string::npos) |
| 617 | iComponentEnd = uri.size(); |
| 618 | |
| 619 | Component component = Component::fromEscapedString(&uri[0], iComponentStart, iComponentEnd); |
| 620 | // Ignore illegal components. This also gets rid of a trailing '/'. |
| 621 | if (!component.empty()) |
| 622 | append(Component(component)); |
| 623 | |
| 624 | iComponentStart = iComponentEnd + 1; |
| 625 | } |
| 626 | } |
| 627 | |
| 628 | inline Name& |
| 629 | Name::append(const Name& name) |
| 630 | { |
| 631 | if (&name == this) |
| 632 | // Copying from this name, so need to make a copy first. |
| 633 | return append(Name(name)); |
| 634 | |
| 635 | for (size_t i = 0; i < name.size(); ++i) |
| 636 | append(name.at(i)); |
| 637 | |
| 638 | return *this; |
| 639 | } |
| 640 | |
| 641 | inline Name& |
| 642 | Name::appendVersion() |
| 643 | { |
| 644 | appendNumber(time::toUnixTimestamp(time::system_clock::now()).count()); |
| 645 | return *this; |
| 646 | } |
| 647 | |
| 648 | inline Name |
| 649 | Name::getSubName(size_t iStartComponent, size_t nComponents) const |
| 650 | { |
| 651 | Name result; |
| 652 | |
| 653 | size_t iEnd = iStartComponent + nComponents; |
| 654 | for (size_t i = iStartComponent; i < iEnd && i < size(); ++i) |
| 655 | result.append(at(i)); |
| 656 | |
| 657 | return result; |
| 658 | } |
| 659 | |
| 660 | inline Name |
| 661 | Name::getSubName(size_t iStartComponent) const |
| 662 | { |
| 663 | Name result; |
| 664 | |
| 665 | for (size_t i = iStartComponent; i < size(); ++i) |
| 666 | result.append(at(i)); |
| 667 | |
| 668 | return result; |
| 669 | } |
| 670 | |
| 671 | inline bool |
| 672 | Name::equals(const Name& name) const |
| 673 | { |
| 674 | if (size() != name.size()) |
| 675 | return false; |
| 676 | |
| 677 | for (size_t i = 0; i < size(); ++i) { |
| 678 | if (at(i) != name.at(i)) |
| 679 | return false; |
| 680 | } |
| 681 | |
| 682 | return true; |
| 683 | } |
| 684 | |
| 685 | inline bool |
| 686 | Name::isPrefixOf(const Name& name) const |
| 687 | { |
| 688 | // This name is longer than the name we are checking it against. |
| 689 | if (size() > name.size()) |
| 690 | return false; |
| 691 | |
| 692 | // Check if at least one of given components doesn't match. |
| 693 | for (size_t i = 0; i < size(); ++i) { |
| 694 | if (at(i) != name.at(i)) |
| 695 | return false; |
| 696 | } |
| 697 | |
| 698 | return true; |
| 699 | } |
| 700 | |
| 701 | |
| 702 | inline int |
| 703 | Name::compare(const Name& other) const |
| 704 | { |
| 705 | for (size_t i = 0; i < size() && i < other.size(); ++i) { |
| 706 | int comparison = at(i).compare(other.at(i)); |
| 707 | if (comparison == 0) |
| 708 | // The components at this index are equal, so check the next components. |
| 709 | continue; |
| 710 | |
| 711 | // Otherwise, the result is based on the components at this index. |
| 712 | return comparison; |
| 713 | } |
| 714 | |
| 715 | // The components up to min(this.size(), other.size()) are equal, so the shorter name is less. |
| 716 | if (size() < other.size()) |
| 717 | return -1; |
| 718 | else if (size() > other.size()) |
| 719 | return 1; |
| 720 | else |
| 721 | return 0; |
| 722 | } |
| 723 | |
| 724 | |
| 725 | |
Alexander Afanasyev | 6d48bc1 | 2014-02-18 00:10:51 -0800 | [diff] [blame] | 726 | template<bool T> |
| 727 | inline size_t |
| 728 | Name::wireEncode(EncodingImpl<T>& blk) const |
| 729 | { |
Alexander Afanasyev | fdbfc6d | 2014-04-14 15:12:11 -0700 | [diff] [blame] | 730 | size_t totalLength = 0; |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 731 | |
Alexander Afanasyev | 1dd95c5 | 2014-03-22 19:11:36 -0700 | [diff] [blame] | 732 | for (const_reverse_iterator i = rbegin(); |
| 733 | i != rend(); |
Alexander Afanasyev | 6d48bc1 | 2014-02-18 00:10:51 -0800 | [diff] [blame] | 734 | ++i) |
| 735 | { |
Alexander Afanasyev | fdbfc6d | 2014-04-14 15:12:11 -0700 | [diff] [blame] | 736 | totalLength += i->wireEncode(blk); |
Alexander Afanasyev | 6d48bc1 | 2014-02-18 00:10:51 -0800 | [diff] [blame] | 737 | } |
| 738 | |
Alexander Afanasyev | fdbfc6d | 2014-04-14 15:12:11 -0700 | [diff] [blame] | 739 | totalLength += blk.prependVarNumber(totalLength); |
| 740 | totalLength += blk.prependVarNumber(Tlv::Name); |
| 741 | return totalLength; |
Alexander Afanasyev | 6d48bc1 | 2014-02-18 00:10:51 -0800 | [diff] [blame] | 742 | } |
| 743 | |
Alexander Afanasyev | 1dd95c5 | 2014-03-22 19:11:36 -0700 | [diff] [blame] | 744 | inline const Block& |
Alexander Afanasyev | 52eb20d | 2014-02-06 18:25:54 -0800 | [diff] [blame] | 745 | Name::wireEncode() const |
| 746 | { |
| 747 | if (m_nameBlock.hasWire()) |
| 748 | return m_nameBlock; |
| 749 | |
Alexander Afanasyev | 380420b | 2014-02-09 20:52:29 -0800 | [diff] [blame] | 750 | EncodingEstimator estimator; |
| 751 | size_t estimatedSize = wireEncode(estimator); |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 752 | |
Alexander Afanasyev | 380420b | 2014-02-09 20:52:29 -0800 | [diff] [blame] | 753 | EncodingBuffer buffer(estimatedSize, 0); |
| 754 | wireEncode(buffer); |
| 755 | |
| 756 | m_nameBlock = buffer.block(); |
| 757 | m_nameBlock.parse(); |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 758 | |
Alexander Afanasyev | 52eb20d | 2014-02-06 18:25:54 -0800 | [diff] [blame] | 759 | return m_nameBlock; |
| 760 | } |
| 761 | |
| 762 | inline void |
Alexander Afanasyev | 1dd95c5 | 2014-03-22 19:11:36 -0700 | [diff] [blame] | 763 | Name::wireDecode(const Block& wire) |
Alexander Afanasyev | 52eb20d | 2014-02-06 18:25:54 -0800 | [diff] [blame] | 764 | { |
Alexander Afanasyev | c348f83 | 2014-02-17 16:35:17 -0800 | [diff] [blame] | 765 | if (wire.type() != Tlv::Name) |
| 766 | throw Tlv::Error("Unexpected TLV type when decoding Name"); |
Alexander Afanasyev | 4b98e8c | 2014-03-22 19:10:19 -0700 | [diff] [blame] | 767 | |
Alexander Afanasyev | 52eb20d | 2014-02-06 18:25:54 -0800 | [diff] [blame] | 768 | m_nameBlock = wire; |
| 769 | m_nameBlock.parse(); |
| 770 | } |
| 771 | |
Alexander Afanasyev | 6d48bc1 | 2014-02-18 00:10:51 -0800 | [diff] [blame] | 772 | inline bool |
| 773 | Name::hasWire() const |
Alexander Afanasyev | 52eb20d | 2014-02-06 18:25:54 -0800 | [diff] [blame] | 774 | { |
Alexander Afanasyev | 6d48bc1 | 2014-02-18 00:10:51 -0800 | [diff] [blame] | 775 | return m_nameBlock.hasWire(); |
Alexander Afanasyev | 52eb20d | 2014-02-06 18:25:54 -0800 | [diff] [blame] | 776 | } |
| 777 | |
Alexander Afanasyev | 95e8c2f | 2014-02-06 17:29:30 -0800 | [diff] [blame] | 778 | } // namespace ndn |
Jeff Thompson | 9c41dfe | 2013-06-27 12:10:25 -0700 | [diff] [blame] | 779 | |
| 780 | #endif |