size_t
Exclude::wireEncode(EncodingImpl<TAG>& encoder) const
{
if (m_exclude.empty()) {
throw Error("Exclude filter cannot be empty");
}
size_t totalLength = 0;
// Exclude ::= EXCLUDE-TYPE TLV-LENGTH Any? (NameComponent (Any)?)+
// Any ::= ANY-TYPE TLV-LENGTH(=0)
for (const auto& item : m_exclude) {
if (item.second) {
totalLength += prependEmptyBlock(encoder, tlv::Any);
}
if (!item.first.empty() || !item.second) {
totalLength += item.first.wireEncode(encoder);
}
}
totalLength += encoder.prependVarNumber(totalLength);
totalLength += encoder.prependVarNumber(tlv::Exclude);
return totalLength;
}
size_t
Route::wireEncode(EncodingImpl<T>& block) const
{
size_t totalLength = 0;
// Absence of an ExpirationPeriod signifies non-expiration
if (!m_hasInfiniteExpirationPeriod) {
totalLength += prependNonNegativeIntegerBlock(block,
ndn::tlv::nfd::ExpirationPeriod,
m_expirationPeriod.count());
}
totalLength += prependNonNegativeIntegerBlock(block,
ndn::tlv::nfd::Flags,
m_flags);
totalLength += prependNonNegativeIntegerBlock(block,
ndn::tlv::nfd::Cost,
m_cost);
totalLength += prependNonNegativeIntegerBlock(block,
ndn::tlv::nfd::Origin,
m_origin);
totalLength += prependNonNegativeIntegerBlock(block,
ndn::tlv::nfd::FaceId,
m_faceId);
totalLength += block.prependVarNumber(totalLength);
totalLength += block.prependVarNumber(ndn::tlv::nfd::Route);
return totalLength;
}
size_t
Exclude::wireEncode(EncodingImpl<TAG>& encoder) const
{
if (m_entries.empty()) {
BOOST_THROW_EXCEPTION(Error("cannot encode empty Exclude selector"));
}
size_t totalLength = 0;
// Exclude ::= EXCLUDE-TYPE TLV-LENGTH Any? (GenericNameComponent (Any)?)+
// Any ::= ANY-TYPE TLV-LENGTH(=0)
for (const Entry& entry : m_entries) {
if (entry.second) {
totalLength += prependEmptyBlock(encoder, tlv::Any);
}
if (!entry.first.isNegInf) {
totalLength += entry.first.component.wireEncode(encoder);
}
}
totalLength += encoder.prependVarNumber(totalLength);
totalLength += encoder.prependVarNumber(tlv::Exclude);
return totalLength;
}
size_t
wireEncode(EncodingImpl<T>& encoder) const
{
size_t totalLength = 0;
totalLength += prependNonNegativeIntegerBlock(encoder,
ndn::statusCollector::tlv::RX,
m_rx);
totalLength += prependNonNegativeIntegerBlock(encoder,
ndn::statusCollector::tlv::TX,
m_tx);
totalLength += prependNonNegativeIntegerBlock(encoder,
ndn::statusCollector::tlv::FaceId,
m_faceId);
totalLength += encoder.prependByteArrayBlock(ndn::statusCollector::tlv::LinkIp,
reinterpret_cast<const uint8_t*>(m_linkIp.c_str()), m_linkIp.size());
totalLength += encoder.prependByteArrayBlock(ndn::statusCollector::tlv::CurrentTime,
reinterpret_cast<const uint8_t*>(m_timestamp.c_str()), m_timestamp.size());
totalLength += encoder.prependVarNumber(totalLength);
totalLength += encoder.prependVarNumber(statusCollector::tlv::FaceStatus);
return totalLength;
}
size_t
FaceEventNotification::wireEncode(EncodingImpl<TAG>& encoder) const
{
size_t totalLength = 0;
totalLength += prependNonNegativeIntegerBlock(encoder,
tlv::nfd::Flags, m_flags);
totalLength += prependNonNegativeIntegerBlock(encoder,
tlv::nfd::LinkType, m_linkType);
totalLength += prependNonNegativeIntegerBlock(encoder,
tlv::nfd::FacePersistency, m_facePersistency);
totalLength += prependNonNegativeIntegerBlock(encoder,
tlv::nfd::FaceScope, m_faceScope);
totalLength += encoder.prependByteArrayBlock(tlv::nfd::LocalUri,
reinterpret_cast<const uint8_t*>(m_localUri.c_str()), m_localUri.size());
totalLength += encoder.prependByteArrayBlock(tlv::nfd::Uri,
reinterpret_cast<const uint8_t*>(m_remoteUri.c_str()), m_remoteUri.size());
totalLength += prependNonNegativeIntegerBlock(encoder,
tlv::nfd::FaceId, m_faceId);
totalLength += prependNonNegativeIntegerBlock(encoder,
tlv::nfd::FaceEventKind, m_kind);
totalLength += encoder.prependVarNumber(totalLength);
totalLength += encoder.prependVarNumber(tlv::nfd::FaceEventNotification);
return totalLength;
}
size_t
Exclude::wireEncode(EncodingImpl<T>& block) const
{
if (m_exclude.empty()) {
throw Error("Exclude filter cannot be empty");
}
size_t totalLength = 0;
// Exclude ::= EXCLUDE-TYPE TLV-LENGTH Any? (NameComponent (Any)?)+
// Any ::= ANY-TYPE TLV-LENGTH(=0)
for (Exclude::const_iterator i = m_exclude.begin(); i != m_exclude.end(); i++)
{
if (i->second)
{
totalLength += prependBooleanBlock(block, tlv::Any);
}
if (!i->first.empty())
{
totalLength += i->first.wireEncode(block);
}
}
totalLength += block.prependVarNumber(totalLength);
totalLength += block.prependVarNumber(tlv::Exclude);
return totalLength;
}
size_t
KeyLocator::wireEncode(EncodingImpl<TAG>& encoder) const
{
// KeyLocator ::= KEY-LOCATOR-TYPE TLV-LENGTH (Name | KeyDigest)
// KeyDigest ::= KEY-DIGEST-TYPE TLV-LENGTH BYTE+
size_t totalLength = 0;
switch (m_type) {
case KeyLocator_None:
break;
case KeyLocator_Name:
totalLength += m_name.wireEncode(encoder);
break;
case KeyLocator_KeyDigest:
totalLength += encoder.prependBlock(m_keyDigest);
break;
default:
NDN_THROW(Error("Unsupported KeyLocator type " + to_string(m_type)));
}
totalLength += encoder.prependVarNumber(totalLength);
totalLength += encoder.prependVarNumber(tlv::KeyLocator);
return totalLength;
}
size_t
DefaultParam::wireEncode(EncodingImpl<T>& block) const
{
size_t totalLength = 0;
switch (m_originType) {
case TYPE_ID:
case TYPE_KEY:
case TYPE_CERT:
{
totalLength += m_originName.wireEncode(block);
break;
}
case TYPE_USER:
break;
default:
throw Error("DefaultParam::wireEncode: unsupported PibType: " +
boost::lexical_cast<std::string>(m_originType));
}
totalLength += prependNonNegativeIntegerBlock(block, tlv::pib::Type, m_originType);
totalLength += prependNonNegativeIntegerBlock(block, tlv::pib::Type, m_targetType);
totalLength += block.prependVarNumber(totalLength);
totalLength += block.prependVarNumber(tlv::pib::DefaultParam);
return totalLength;
}
size_t
Interest::wireEncode(EncodingImpl<TAG>& block) const
{
size_t totalLength = 0;
// Interest ::= INTEREST-TYPE TLV-LENGTH
// Name
// Selectors?
// Nonce
// Scope?
// InterestLifetime?
// Link?
// SelectedDelegation?
// (reverse encoding)
if (hasLink()) {
if (hasSelectedDelegation()) {
totalLength += prependNonNegativeIntegerBlock(block,
tlv::SelectedDelegation,
m_selectedDelegationIndex);
}
totalLength += prependBlock(block, m_link);
}
else {
BOOST_ASSERT(!hasSelectedDelegation());
}
// InterestLifetime
if (getInterestLifetime() >= time::milliseconds::zero() &&
getInterestLifetime() != DEFAULT_INTEREST_LIFETIME)
{
totalLength += prependNonNegativeIntegerBlock(block,
tlv::InterestLifetime,
getInterestLifetime().count());
}
// Scope
if (getScope() >= 0)
{
totalLength += prependNonNegativeIntegerBlock(block, tlv::Scope, getScope());
}
// Nonce
getNonce(); // to ensure that Nonce is properly set
totalLength += block.prependBlock(m_nonce);
// Selectors
if (hasSelectors())
{
totalLength += getSelectors().wireEncode(block);
}
// Name
totalLength += getName().wireEncode(block);
totalLength += block.prependVarNumber(totalLength);
totalLength += block.prependVarNumber(tlv::Interest);
return totalLength;
}
size_t
Interest::encode03(EncodingImpl<TAG>& encoder) const
{
size_t totalLength = 0;
// Encode as NDN Packet Format v0.3
// Interest ::= INTEREST-TYPE TLV-LENGTH
// Name
// CanBePrefix?
// MustBeFresh?
// ForwardingHint?
// Nonce?
// InterestLifetime?
// HopLimit?
// ApplicationParameters?
// (reverse encoding)
// ApplicationParameters
if (hasApplicationParameters()) {
totalLength += encoder.prependBlock(getApplicationParameters());
}
// HopLimit: not yet supported
// InterestLifetime
if (getInterestLifetime() != DEFAULT_INTEREST_LIFETIME) {
totalLength += prependNonNegativeIntegerBlock(encoder, tlv::InterestLifetime,
static_cast<uint64_t>(getInterestLifetime().count()));
}
// Nonce
uint32_t nonce = getNonce(); // if nonce was unset, getNonce generates a random nonce
totalLength += encoder.prependByteArrayBlock(tlv::Nonce, reinterpret_cast<uint8_t*>(&nonce), sizeof(nonce));
// ForwardingHint
if (!getForwardingHint().empty()) {
totalLength += getForwardingHint().wireEncode(encoder);
}
// MustBeFresh
if (getMustBeFresh()) {
totalLength += prependEmptyBlock(encoder, tlv::MustBeFresh);
}
// CanBePrefix
if (getCanBePrefix()) {
totalLength += prependEmptyBlock(encoder, tlv::CanBePrefix);
}
// Name
totalLength += getName().wireEncode(encoder);
totalLength += encoder.prependVarNumber(totalLength);
totalLength += encoder.prependVarNumber(tlv::Interest);
return totalLength;
}
size_t
NackHeader::wireEncode(EncodingImpl<TAG>& encoder) const
{
size_t length = 0;
length += prependNonNegativeIntegerBlock(encoder, tlv::NackReason,
static_cast<uint32_t>(m_reason));
length += encoder.prependVarNumber(length);
length += encoder.prependVarNumber(tlv::Nack);
return length;
}
size_t
Component::wireEncode(EncodingImpl<TAG>& encoder) const
{
size_t totalLength = 0;
if (value_size() > 0)
totalLength += encoder.prependByteArray(value(), value_size());
totalLength += encoder.prependVarNumber(value_size());
totalLength += encoder.prependVarNumber(type());
return totalLength;
}
size_t
wireEncode(EncodingImpl<T>& encoder) const
{
size_t bytes_encoded = 0;
bytes_encoded += encoder.prependByteArrayBlock(ndn::statusCollector::tlv::ScriptData, reinterpret_cast<const uint8_t*>(m_data.c_str()), m_data.size());
bytes_encoded += encoder.prependVarNumber(bytes_encoded);
bytes_encoded += encoder.prependVarNumber(statusCollector::tlv::ScriptPacket);
return bytes_encoded;
}
size_t
StrategyChoice::wireEncode(EncodingImpl<TAG>& encoder) const
{
size_t totalLength = 0;
totalLength += prependNestedBlock(encoder, tlv::nfd::Strategy, m_strategy);
totalLength += m_name.wireEncode(encoder);
totalLength += encoder.prependVarNumber(totalLength);
totalLength += encoder.prependVarNumber(tlv::nfd::StrategyChoice);
return totalLength;
}
inline size_t
prependNestedBlock(EncodingImpl<TAG>& encoder, uint32_t type, const U& value)
{
BOOST_CONCEPT_ASSERT((WireEncodableWithEncodingBuffer<U>));
size_t valueLength = value.wireEncode(encoder);
size_t totalLength = valueLength;
totalLength += encoder.prependVarNumber(valueLength);
totalLength += encoder.prependVarNumber(type);
return totalLength;
}
size_t
ValidityPeriod::wireEncode(EncodingImpl<TAG>& encoder) const
{
size_t totalLength = 0;
totalLength += prependStringBlock(encoder, tlv::NotAfter, time::toIsoString(m_notAfter));
totalLength += prependStringBlock(encoder, tlv::NotBefore, time::toIsoString(m_notBefore));
totalLength += encoder.prependVarNumber(totalLength);
totalLength += encoder.prependVarNumber(tlv::ValidityPeriod);
return totalLength;
}
size_t
CachePolicy::wireEncode(EncodingImpl<TAG>& encoder) const
{
if (m_policy == CachePolicyType::NONE) {
BOOST_THROW_EXCEPTION(Error("CachePolicyType must be set"));
}
size_t length = 0;
length += prependNonNegativeIntegerBlock(encoder, tlv::CachePolicyType, static_cast<uint32_t>(m_policy));
length += encoder.prependVarNumber(length);
length += encoder.prependVarNumber(tlv::CachePolicy);
return length;
}
size_t
Name::wireEncode(EncodingImpl<T>& encoder) const
{
size_t totalLength = 0;
for (const_reverse_iterator i = rbegin(); i != rend(); ++i)
{
totalLength += i->wireEncode(encoder);
}
totalLength += encoder.prependVarNumber(totalLength);
totalLength += encoder.prependVarNumber(tlv::Name);
return totalLength;
}
size_t
Schedule::wireEncode(EncodingImpl<TAG>& encoder) const
{
size_t totalLength = 0;
size_t blackLength = 0;
size_t whiteLength = 0;
// encode the blackIntervalList as an embed TLV structure
for (const RepetitiveInterval& element : m_blackIntervalList) {
blackLength += encoder.prependBlock(element.wireEncode());
}
blackLength += encoder.prependVarNumber(blackLength);
blackLength += encoder.prependVarNumber(tlv::BlackIntervalList);
// encode the whiteIntervalList as an embed TLV structure
for (const RepetitiveInterval& element : m_whiteIntervalList) {
whiteLength += encoder.prependBlock(element.wireEncode());
}
whiteLength += encoder.prependVarNumber(whiteLength);
whiteLength += encoder.prependVarNumber(tlv::WhiteIntervalList);
totalLength = whiteLength + blackLength;
totalLength += encoder.prependVarNumber(totalLength);
totalLength += encoder.prependVarNumber(tlv::Schedule);
return totalLength;
}
size_t
wireEncode(EncodingImpl<T>& encoder) const
{
size_t totalLength = 0;
for (std::vector<Name>::const_reverse_iterator i = m_prefixes.rbegin();
i != m_prefixes.rend(); ++i) {
totalLength += i->wireEncode(encoder);
}
totalLength += encoder.prependVarNumber(totalLength);
totalLength += encoder.prependVarNumber(tlv::Content);
return totalLength;
}
size_t
FibEntry::wireEncode(EncodingImpl<TAG>& block) const
{
size_t totalLength = 0;
for (auto i = m_nextHopRecords.rbegin(); i != m_nextHopRecords.rend(); ++i) {
totalLength += i->wireEncode(block);
}
totalLength += m_prefix.wireEncode(block);
totalLength += block.prependVarNumber(totalLength);
totalLength += block.prependVarNumber(tlv::nfd::FibEntry);
return totalLength;
}
size_t
NextHopRecord::wireEncode(EncodingImpl<TAG>& block) const
{
size_t totalLength = 0;
totalLength += prependNonNegativeIntegerBlock(block,
ndn::tlv::nfd::Cost,
m_cost);
totalLength += prependNonNegativeIntegerBlock(block,
ndn::tlv::nfd::FaceId,
m_faceId);
totalLength += block.prependVarNumber(totalLength);
totalLength += block.prependVarNumber(ndn::tlv::nfd::NextHopRecord);
return totalLength;
}
size_t
RibEntry::wireEncode(EncodingImpl<T>& block) const
{
size_t totalLength = 0;
for (std::list<Route>::const_reverse_iterator it = m_routes.rbegin();
it != m_routes.rend(); ++it)
{
totalLength += it->wireEncode(block);
}
totalLength += m_prefix.wireEncode(block);
totalLength += block.prependVarNumber(totalLength);
totalLength += block.prependVarNumber(tlv::nfd::RibEntry);
return totalLength;
}
size_t
Packet::wireEncode(EncodingImpl<TAG>& encoder) const
{
if (m_wire.hasWire()) {
return m_wire.size();
}
size_t length = 0;
for (const Block& element : boost::adaptors::reverse(m_wire.elements())) {
length += encoder.prependBlock(element);
}
length += encoder.prependVarNumber(length);
length += encoder.prependVarNumber(tlv::LpPacket);
return length;
}
size_t
FaceEventNotification::wireEncode(EncodingImpl<TAG>& encoder) const
{
size_t totalLength = 0;
totalLength += prependNonNegativeIntegerBlock(encoder, tlv::nfd::Flags, m_flags);
totalLength += prependNonNegativeIntegerBlock(encoder, tlv::nfd::LinkType, m_linkType);
totalLength += prependNonNegativeIntegerBlock(encoder, tlv::nfd::FacePersistency, m_facePersistency);
totalLength += prependNonNegativeIntegerBlock(encoder, tlv::nfd::FaceScope, m_faceScope);
totalLength += prependStringBlock(encoder, tlv::nfd::LocalUri, m_localUri);
totalLength += prependStringBlock(encoder, tlv::nfd::Uri, m_remoteUri);
totalLength += prependNonNegativeIntegerBlock(encoder, tlv::nfd::FaceId, m_faceId);
totalLength += prependNonNegativeIntegerBlock(encoder, tlv::nfd::FaceEventKind, m_kind);
totalLength += encoder.prependVarNumber(totalLength);
totalLength += encoder.prependVarNumber(tlv::nfd::FaceEventNotification);
return totalLength;
}
size_t
wireEncode(EncodingImpl<T>& encoder) const
{
size_t totalLength = 0;
for (std::vector<FaceStatus>::const_reverse_iterator i = m_statusList.rbegin();
i != m_statusList.rend(); ++i)
{
totalLength += i->wireEncode(encoder);
}
// totalLength += m_prefix.wireEncode(block);
totalLength += encoder.prependVarNumber(totalLength);
totalLength += encoder.prependVarNumber(statusCollector::tlv::CollectorReply);
return totalLength;
}
size_t
FaceStatus::wireEncode(EncodingImpl<TAG>& encoder) const
{
size_t totalLength = 0;
totalLength += prependNonNegativeIntegerBlock(encoder,
tlv::nfd::Flags, m_flags);
totalLength += prependNonNegativeIntegerBlock(encoder,
tlv::nfd::NOutBytes, m_nOutBytes);
totalLength += prependNonNegativeIntegerBlock(encoder,
tlv::nfd::NInBytes, m_nInBytes);
totalLength += prependNonNegativeIntegerBlock(encoder,
tlv::nfd::NOutNacks, m_nOutNacks);
totalLength += prependNonNegativeIntegerBlock(encoder,
tlv::nfd::NOutDatas, m_nOutDatas);
totalLength += prependNonNegativeIntegerBlock(encoder,
tlv::nfd::NOutInterests, m_nOutInterests);
totalLength += prependNonNegativeIntegerBlock(encoder,
tlv::nfd::NInNacks, m_nInNacks);
totalLength += prependNonNegativeIntegerBlock(encoder,
tlv::nfd::NInDatas, m_nInDatas);
totalLength += prependNonNegativeIntegerBlock(encoder,
tlv::nfd::NInInterests, m_nInInterests);
totalLength += prependNonNegativeIntegerBlock(encoder,
tlv::nfd::LinkType, m_linkType);
totalLength += prependNonNegativeIntegerBlock(encoder,
tlv::nfd::FacePersistency, m_facePersistency);
totalLength += prependNonNegativeIntegerBlock(encoder,
tlv::nfd::FaceScope, m_faceScope);
if (m_hasExpirationPeriod) {
totalLength += prependNonNegativeIntegerBlock(encoder,
tlv::nfd::ExpirationPeriod, m_expirationPeriod.count());
}
totalLength += encoder.prependByteArrayBlock(tlv::nfd::LocalUri,
reinterpret_cast<const uint8_t*>(m_localUri.c_str()), m_localUri.size());
totalLength += encoder.prependByteArrayBlock(tlv::nfd::Uri,
reinterpret_cast<const uint8_t*>(m_remoteUri.c_str()), m_remoteUri.size());
totalLength += prependNonNegativeIntegerBlock(encoder,
tlv::nfd::FaceId, m_faceId);
totalLength += encoder.prependVarNumber(totalLength);
totalLength += encoder.prependVarNumber(tlv::nfd::FaceStatus);
return totalLength;
}
size_t
Interest::wireEncode(EncodingImpl<TAG>& encoder) const
{
size_t totalLength = 0;
// Interest ::= INTEREST-TYPE TLV-LENGTH
// Name
// Selectors?
// Nonce
// InterestLifetime?
// ForwardingHint?
// (reverse encoding)
// ForwardingHint
if (m_forwardingHint.size() > 0) {
totalLength += m_forwardingHint.wireEncode(encoder);
}
// InterestLifetime
if (getInterestLifetime() != DEFAULT_INTEREST_LIFETIME) {
totalLength += prependNonNegativeIntegerBlock(encoder,
tlv::InterestLifetime,
getInterestLifetime().count());
}
// Nonce
uint32_t nonce = this->getNonce(); // assigns random Nonce if needed
totalLength += encoder.prependByteArray(reinterpret_cast<uint8_t*>(&nonce), sizeof(nonce));
totalLength += encoder.prependVarNumber(sizeof(nonce));
totalLength += encoder.prependVarNumber(tlv::Nonce);
// Selectors
if (hasSelectors()) {
totalLength += getSelectors().wireEncode(encoder);
}
// Name
totalLength += getName().wireEncode(encoder);
totalLength += encoder.prependVarNumber(totalLength);
totalLength += encoder.prependVarNumber(tlv::Interest);
return totalLength;
}
size_t
FaceQueryFilter::wireEncode(EncodingImpl<TAG>& encoder) const
{
size_t totalLength = 0;
if (m_hasLinkType) {
totalLength += prependNonNegativeIntegerBlock(encoder,
tlv::nfd::LinkType, m_linkType);
}
if (m_hasFacePersistency) {
totalLength += prependNonNegativeIntegerBlock(encoder,
tlv::nfd::FacePersistency, m_facePersistency);
}
if (m_hasFaceScope) {
totalLength += prependNonNegativeIntegerBlock(encoder,
tlv::nfd::FaceScope, m_faceScope);
}
if (m_hasLocalUri) {
totalLength += encoder.prependByteArrayBlock(tlv::nfd::LocalUri,
reinterpret_cast<const uint8_t*>(m_localUri.c_str()), m_localUri.size());
}
if (m_hasRemoteUri) {
totalLength += encoder.prependByteArrayBlock(tlv::nfd::Uri,
reinterpret_cast<const uint8_t*>(m_remoteUri.c_str()), m_remoteUri.size());
}
if (m_hasUriScheme) {
totalLength += encoder.prependByteArrayBlock(tlv::nfd::UriScheme,
reinterpret_cast<const uint8_t*>(m_uriScheme.c_str()), m_uriScheme.size());
}
if (m_hasFaceId) {
totalLength += prependNonNegativeIntegerBlock(encoder,
tlv::nfd::FaceId, m_faceId);
}
totalLength += encoder.prependVarNumber(totalLength);
totalLength += encoder.prependVarNumber(tlv::nfd::FaceQueryFilter);
return totalLength;
}
size_t
Data::wireEncode(EncodingImpl<TAG>& encoder, bool unsignedPortion/* = false*/) const
{
size_t totalLength = 0;
// Data ::= DATA-TLV TLV-LENGTH
// Name
// MetaInfo
// Content
// Signature
// (reverse encoding)
if (!unsignedPortion && !m_signature)
{
BOOST_THROW_EXCEPTION(Error("Requested wire format, but data packet has not been signed yet"));
}
if (!unsignedPortion)
{
// SignatureValue
totalLength += encoder.prependBlock(m_signature.getValue());
}
// SignatureInfo
totalLength += encoder.prependBlock(m_signature.getInfo());
// Content
totalLength += encoder.prependBlock(getContent());
// MetaInfo
totalLength += getMetaInfo().wireEncode(encoder);
// Name
totalLength += getName().wireEncode(encoder);
if (!unsignedPortion)
{
totalLength += encoder.prependVarNumber(totalLength);
totalLength += encoder.prependVarNumber(tlv::Data);
}
return totalLength;
}
