convention.hpp

Go to the documentation of this file.

#ifndef NDNPH_PACKET_CONVENTION_HPP
#define NDNPH_PACKET_CONVENTION_HPP
 
#include "../port/random/port.hpp"
#include "../port/unixtime/port.hpp"
#include "../tlv/nni.hpp"
#include "component.hpp"
 
namespace ndnph {
namespace convention {
 
class RandomValue {
public:
  std::pair<bool, uint64_t> toNumber() const {
    uint64_t value = 0;
    bool ok = port::RandomSource::generate(reinterpret_cast<uint8_t*>(&value), sizeof(value));
    return std::make_pair(ok, value);
  }
  std::pair<bool, uint64_t> toNumber() const  {…}
};
class RandomValue {…};
 
class TimeValue {
public:
  enum Unit {
    Seconds = 1000000,
    Milliseconds = 1000,
    Microseconds = 1,
  };
  enum Unit {…};
 
  explicit TimeValue(uint64_t t = 0, uint64_t unit = Microseconds, bool allowFallback = false)
    : m_t(t)
    , m_unit(unit)
    , m_allowFallback(allowFallback) {}
  explicit TimeValue(uint64_t t = 0, uint64_t unit = Microseconds, bool allowFallback = false) {…}
 
  std::pair<bool, uint64_t> toNumber() const {
    uint64_t t = m_t;
    if (t == 0) {
      t = port::UnixTime::now();
      if (!port::UnixTime::valid(t)) {
        if (m_allowFallback) {
          return RandomValue().toNumber();
        } else {
          return std::make_pair(false, 0);
        }
      }
    }
    return std::make_pair(true, t / m_unit);
  }
  std::pair<bool, uint64_t> toNumber() const  {…}
 
private:
  uint64_t m_t;
  uint64_t m_unit;
  bool m_allowFallback;
};
class TimeValue {…};
 
namespace detail {
 
template<uint16_t tlvType>
class TypedDigest {
public:
  static Component create(Region& region, const uint8_t digest[NDNPH_SHA256_LEN]) {
    return Component(region, tlvType, NDNPH_SHA256_LEN, digest);
  }
  static Component create(Region& region, const uint8_t digest[NDNPH_SHA256_LEN]) {…}
 
  static bool match(const Component& comp) {
    return comp.type() == tlvType && comp.length() == NDNPH_SHA256_LEN;
  }
  static bool match(const Component& comp) {…}
 
  static const uint8_t* parse(const Component& comp) {
    return comp.value();
  }
  static const uint8_t* parse(const Component& comp) {…}
};
class TypedDigest {…};
 
template<uint16_t tlvType>
class TypedString {
public:
  static Component create(Region& region, const char* s) {
    return Component(region, tlvType, std::strlen(s), reinterpret_cast<const uint8_t*>(s));
  }
  static Component create(Region& region, const char* s) {…}
 
  static bool match(const Component& comp) {
    return comp.type() == tlvType;
  }
  static bool match(const Component& comp) {…}
 
  static const char* parse(const Component& comp, Region& region) {
    uint8_t* room = region.alloc(comp.length() + 1);
    if (room == nullptr) {
      return nullptr;
    }
    std::copy_n(comp.value(), comp.length(), room)[0] = 0;
    return reinterpret_cast<const char*>(room);
  }
  static const char* parse(const Component& comp, Region& region) {…}
};
class TypedString {…};
 
template<uint16_t tlvType>
class TypedNumber {
public:
  static Component create(Region& region, uint64_t value) {
    return Component::from(region, tlvType, tlv::NNI(value));
  }
  static Component create(Region& region, uint64_t value) {…}
 
  template<typename G>
  static Component create(Region& region, const G& gen, decltype(&G::toNumber) = nullptr) {
    bool ok = false;
    uint64_t value = 0;
    std::tie(ok, value) = gen.toNumber();
    if (!ok) {
      return Component();
    }
    return create(region, value);
  }
  static Component create(Region& region, const G& gen, decltype(&G::toNumber) = nullptr) {…}
 
  static bool match(const Component& comp) {
    return parseImpl(comp).first;
  }
  static bool match(const Component& comp) {…}
 
  static uint64_t parse(const Component& comp) {
    return parseImpl(comp).second;
  }
  static uint64_t parse(const Component& comp) {…}
 
private:
  static std::pair<bool, uint64_t> parseImpl(const Component& comp) {
    Decoder::Tlv d;
    uint64_t value = 0;
    bool ok = comp.type() == tlvType && Decoder::readTlv(d, comp.tlv(), comp.tlv() + comp.size()) &&
              tlv::NNI::decode(d, value);
    return std::make_pair(ok, value);
  }
};
class TypedNumber {…};
 
} // namespace detail
namespace detail {…}
 
using ImplicitDigest = detail::TypedDigest<TT::ImplicitSha256DigestComponent>;
 
using ParamsDigest = detail::TypedDigest<TT::ParametersSha256DigestComponent>;
 
using Keyword = detail::TypedString<TT::KeywordNameComponent>;
 
using GenericNumber = detail::TypedNumber<TT::GenericNameComponent>;
 
using Segment = detail::TypedNumber<TT::SegmentNameComponent>;
 
using ByteOffset = detail::TypedNumber<TT::ByteOffsetNameComponent>;
 
using Version = detail::TypedNumber<TT::VersionNameComponent>;
 
using Timestamp = detail::TypedNumber<TT::TimestampNameComponent>;
 
using SequenceNum = detail::TypedNumber<TT::SequenceNumNameComponent>;
 
} // namespace convention
namespace convention {…}
} // namespace ndnph
 
#endif // NDNPH_PACKET_CONVENTION_HPP