data.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "ndn/common.hpp"
#include "ndn/name.hpp"
#include "ndn/signature.hpp"
 
namespace ndn {
 
class Data {
public:
    Data() = default;
 
    explicit Data(const Name& name);
 
    static Result<Data> fromWire(const uint8_t* buf, size_t len);
    Error encode(uint8_t* buf, size_t bufSize, size_t& encodedLen) const;
    const Name& name() const { return name_; }
 
    Name& name() { return name_; }
 
    Data& setName(const Name& name);
 
    Error setName(std::string_view uri);
    const uint8_t* content() const { return content_.data(); }
 
    size_t contentSize() const { return contentSize_; }
 
    bool hasContent() const { return contentSize_ > 0; }
 
    Error setContent(const uint8_t* data, size_t size);
 
    Error setContent(std::string_view str);
    ContentType contentType() const { return contentType_; }
 
    Data& setContentType(ContentType type);
 
    bool isLink() const { return contentType_ == ContentType::Link; }
    std::optional<uint32_t> freshnessPeriod() const { return freshnessPeriod_; }
 
    Data& setFreshnessPeriod(uint32_t periodMs);
    std::optional<uint64_t> finalBlockId() const { return finalBlockId_; }
 
    bool hasFinalBlockId() const { return finalBlockId_.has_value(); }
 
    Data& setFinalBlockId(uint64_t segmentNum);
 
    Data& clearFinalBlockId();
    SignatureType signatureType() const { return signatureType_; }
 
    Data& setSignatureType(SignatureType type);
 
    const Name* keyLocator() const { return hasKeyLocator_ ? &keyLocator_ : nullptr; }
 
    bool hasKeyLocator() const { return hasKeyLocator_; }
 
    Data& setKeyLocator(const Name& name);
 
    Data& clearKeyLocator();
 
    const uint8_t* signatureValue() const { return signatureValue_.data(); }
 
    size_t signatureValueSize() const { return signatureSize_; }
 
    bool hasSignature() const { return signatureSize_ > 0; }
 
    Error signWithDigestSha256();
 
    Error signWithHmac(const uint8_t* key, size_t keyLen);
 
    bool verifyDigestSha256() const;
 
    bool verifyHmac(const uint8_t* key, size_t keyLen) const;
 
    Error signWithEcdsa(const uint8_t* privKey);
 
    bool verifyEcdsa(const uint8_t* pubKey) const;
private:
    Error encodeSignedPortion(uint8_t* buf, size_t bufSize, size_t& encodedLen) const;
 
    Name name_;                                                  
    std::array<uint8_t, DATA_MAX_CONTENT_SIZE> content_{};       
    size_t contentSize_ = 0;                                     
    ContentType contentType_ = ContentType::Blob;                
    std::optional<uint32_t> freshnessPeriod_;                    
    std::optional<uint64_t> finalBlockId_;                       
    SignatureType signatureType_ = SignatureType::DigestSha256;  
    Name keyLocator_;                                            
    bool hasKeyLocator_ = false;                                 
    std::array<uint8_t, SIGNATURE_MAX_SIZE> signatureValue_{};   
    size_t signatureSize_ = 0;                                   
};
 
}  // namespace ndn