32 #include <boost/functional/hash.hpp>
33 #include <boost/range/adaptor/reversed.hpp>
34 #include <boost/range/concepts.hpp>
38 BOOST_CONCEPT_ASSERT((boost::EqualityComparable<Name>));
39 BOOST_CONCEPT_ASSERT((WireEncodable<Name>));
40 BOOST_CONCEPT_ASSERT((WireEncodableWithEncodingBuffer<Name>));
41 BOOST_CONCEPT_ASSERT((WireDecodable<Name>));
42 BOOST_CONCEPT_ASSERT((boost::RandomAccessIterator<Name::iterator>));
43 BOOST_CONCEPT_ASSERT((boost::RandomAccessIterator<Name::const_iterator>));
44 BOOST_CONCEPT_ASSERT((boost::RandomAccessIterator<Name::reverse_iterator>));
45 BOOST_CONCEPT_ASSERT((boost::RandomAccessIterator<Name::const_reverse_iterator>));
46 BOOST_CONCEPT_ASSERT((boost::RandomAccessRangeConcept<Name>));
47 static_assert(std::is_base_of<tlv::Error, Name::Error>::value,
48 "Name::Error must inherit from tlv::Error");
50 const size_t Name::npos = std::numeric_limits<size_t>::max();
66 :
Name(std::string(uri))
75 size_t iColon = uri.find(
':');
76 if (iColon != std::string::npos) {
78 size_t iFirstSlash = uri.find(
'/');
79 if (iFirstSlash == std::string::npos || iColon < iFirstSlash) {
81 uri.erase(0, iColon + 1);
87 if (uri.size() >= 2 && uri[1] ==
'/') {
89 size_t iAfterAuthority = uri.find(
'/', 2);
90 if (iAfterAuthority == std::string::npos)
94 uri.erase(0, iAfterAuthority + 1);
102 size_t iComponentStart = 0;
105 while (iComponentStart < uri.size()) {
106 size_t iComponentEnd = uri.find(
'/', iComponentStart);
107 if (iComponentEnd == std::string::npos)
108 iComponentEnd = uri.size();
111 iComponentStart = iComponentEnd + 1;
115 template<encoding::Tag TAG>
119 size_t totalLength = 0;
120 for (
const Component& comp : *
this | boost::adaptors::reversed) {
121 totalLength += comp.wireEncode(encoder);
124 totalLength += encoder.prependVarNumber(totalLength);
125 totalLength += encoder.prependVarNumber(
tlv::Name);
143 m_wire = buffer.block();
162 Name copiedName(*
this);
173 auto ssize =
static_cast<ssize_t
>(
size());
174 if (i < -ssize || i >= ssize) {
189 if (iStartComponent < 0)
190 iStartComponent +=
static_cast<ssize_t
>(
size());
191 size_t iStart = iStartComponent < 0 ? 0 : static_cast<size_t>(iStartComponent);
193 size_t iEnd =
size();
194 if (nComponents !=
npos)
195 iEnd = std::min(
size(), iStart + nComponents);
197 for (
size_t i = iStart; i < iEnd; ++i)
209 i +=
static_cast<ssize_t
>(
size());
221 i +=
static_cast<ssize_t
>(
size());
249 for (
const auto& c : name) {
255 static constexpr uint8_t SHA256_OF_EMPTY_STRING[] = {
256 0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14,
257 0x9a, 0xfb, 0xf4, 0xc8, 0x99, 0x6f, 0xb9, 0x24,
258 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c,
259 0xa4, 0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55,
266 return append(placeholder);
292 static const Name n(
"/sha256digest=0000000000000000000000000000000000000000000000000000000000000000");
303 if (size() > other.size())
307 for (
size_t i = 0; i < size(); ++i) {
308 if (get(i) != other.get(i))
318 if (size() != other.size())
321 for (
size_t i = 0; i < size(); ++i) {
322 if (get(i) != other.get(i))
332 count1 = std::min(count1, this->
size() - pos1);
333 count2 = std::min(count2, other.
size() - pos2);
334 size_t count = std::min(count1, count2);
336 for (
size_t i = 0; i < count; ++i) {
343 return count1 - count2;
356 for (
const auto& component : *
this) {
358 component.toUri(os, format);
365 std::ostringstream os;
373 std::string inputString;
375 name =
Name(inputString);
Represents a TLV element of the NDN packet format.
element_const_iterator elements_begin() const noexcept
Equivalent to elements().begin().
element_iterator erase(element_const_iterator position)
Erase a sub-element.
const element_container & elements() const noexcept
Get container of sub-elements.
element_const_iterator elements_end() const noexcept
Equivalent to elements().end().
bool hasWire() const noexcept
Check if the Block contains a fully encoded wire representation.
void resetWire() noexcept
Reset wire buffer but keep TLV-TYPE and sub-elements (if any)
uint32_t type() const noexcept
Return the TLV-TYPE of the Block.
std::vector< Block > element_container
void parse() const
Parse TLV-VALUE into sub-elements.
Represents an absolute name.
bool equals(const Name &other) const noexcept
Check if this name equals another name.
name::Component::Error Error
Name & set(ssize_t i, const Component &component)
Replace the component at the specified index.
Name getSuccessor() const
Get the successor of a name.
PartialName getPrefix(ssize_t nComponents) const
Returns a prefix of the name.
Name & appendTimestamp(const optional< time::system_clock::time_point > ×tamp=nullopt)
Append a timestamp component.
int compare(const Name &other) const
Compare this to the other Name using NDN canonical ordering.
Name & appendParametersSha256DigestPlaceholder()
Append a placeholder for a ParametersSha256Digest component.
size_t size() const noexcept
Returns the number of components.
Name & appendVersion(const optional< uint64_t > &version=nullopt)
Append a version component.
bool empty() const noexcept
Checks if the name is empty, i.e., has no components.
void clear()
Remove all components.
Name & append(const Component &component)
Append a name component.
Name()
Create an empty name.
const Component & at(ssize_t i) const
Returns an immutable reference to the component at the specified index, with bounds checking.
static const size_t npos
Indicates "until the end" in getSubName() and compare().
size_t wireEncode(EncodingImpl< TAG > &encoder) const
Fast encoding or block size estimation.
Name deepCopy() const
Make a deep copy of the name, reallocating the underlying memory buffer.
const Block & wireEncode() const
Perform wire encoding, or return existing wire encoding.
PartialName getSubName(ssize_t iStartComponent, size_t nComponents=npos) const
Extracts some components as a sub-name (PartialName).
void erase(ssize_t i)
Erase the component at the specified index.
void toUri(std::ostream &os, name::UriFormat format=name::UriFormat::DEFAULT) const
Write URI representation of the name to the output stream.
bool isPrefixOf(const Name &other) const noexcept
Check if this name is a prefix of another name.
void wireDecode(const Block &wire)
Decode name from wire encoding.
const Component & get(ssize_t i) const noexcept
Returns an immutable reference to the component at the specified index.
Represents a name component.
static Component fromEscapedString(const char *input, size_t beginOffset, size_t endOffset)
Decode NameComponent from a URI component.
static Component fromTimestamp(const time::system_clock::time_point &timePoint)
Create a timestamp component using NDN naming conventions.
static Component fromVersion(uint64_t version)
Create a version component using NDN naming conventions.
int compare(const Component &other) const
Compare this to the other Component using NDN canonical ordering.
static time_point now() noexcept
Represents an error in TLV encoding or decoding.
#define NDN_CXX_DEFINE_WIRE_ENCODE_INSTANTIATIONS(ClassName)
EncodingImpl< EstimatorTag > EncodingEstimator
EncodingImpl< EncoderTag > EncodingBuffer
std::string to_string(const errinfo_stacktrace &x)
UriFormat
Format used for the URI representation of a name.
milliseconds toUnixTimestamp(const system_clock::time_point &point)
Convert system_clock::time_point to UNIX timestamp.
@ ParametersSha256DigestComponent
Name PartialName
Represents an arbitrary sequence of name components.
std::istream & operator>>(std::istream &is, Name &name)
Parse URI from stream as Name.
size_t operator()(const ndn::Name &name) const