name.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "ndn/common.hpp"
 
namespace ndn {
 
struct NameComponent {
    const uint8_t* value;  
    size_t size;           
 
    std::string_view asString() const {
        return std::string_view(reinterpret_cast<const char*>(value), size);
    }
};
 
class Name {
public:
    Name() = default;
 
    static Result<Name> fromUri(std::string_view uri);
 
    static Result<Name> fromWire(const uint8_t* buf, size_t len, size_t* bytesRead = nullptr);
    size_t toUri(char* buf, size_t bufSize) const;
 
    Error encode(uint8_t* buf, size_t bufSize, size_t& encodedLen) const;
    size_t componentCount() const { return numComponents_; }
 
    NameComponent component(size_t index) const;
 
    Error appendComponent(std::string_view comp);
 
    Error appendComponent(const uint8_t* value, size_t len);
    int compare(const Name& other) const;
 
    bool equals(const Name& other) const;
 
    bool isPrefixOf(const Name& other) const;
    uint32_t hash() const;
 
    bool empty() const { return numComponents_ == 0; }
 
    const uint8_t* wireValue() const { return buffer_.data(); }
 
    size_t wireLength() const { return length_; }
private:
    std::array<uint8_t, NAME_MAX_LENGTH> buffer_{};  
    size_t length_ = 0;                              
 
    struct ComponentOffset {
        uint16_t offset;  
        uint16_t length;  
    };
    std::array<ComponentOffset, NAME_MAX_COMPONENTS> components_{};  
    uint8_t numComponents_ = 0;                                      
 
    Error appendComponentInternal(const uint8_t* value, size_t len);
};
 
inline bool operator==(const Name& lhs, const Name& rhs) {
    return lhs.equals(rhs);
}
 
inline bool operator!=(const Name& lhs, const Name& rhs) {
    return !lhs.equals(rhs);
}
 
inline bool operator<(const Name& lhs, const Name& rhs) {
    return lhs.compare(rhs) < 0;
}
}  // namespace ndn