value.hpp

Go to the documentation of this file.

#ifndef NDNPH_TLV_VALUE_HPP
#define NDNPH_TLV_VALUE_HPP
 
#include "decoder.hpp"
#include "encoder.hpp"
 
namespace ndnph {
namespace tlv {
 
class Value {
public:
  static Value fromString(const char* str) {
    return Value(reinterpret_cast<const uint8_t*>(str), std::strlen(str));
  }
  static Value fromString(const char* str) {…}
 
  explicit Value() = default;
 
  explicit Value(const uint8_t* value, size_t size)
    : m_value(value)
    , m_size(size) {}
  explicit Value(const uint8_t* value, size_t size) {…}
 
  explicit Value(const uint8_t* first, const uint8_t* last)
    : m_value(first)
    , m_size(last - first) {}
  explicit Value(const uint8_t* first, const uint8_t* last) {…}
 
  explicit Value(const Encoder& encoder)
    : Value(encoder.begin(), encoder.size()) {}
  explicit Value(const Encoder& encoder) {…}
 
  explicit operator bool() const {
    return size() > 0;
  }
  explicit operator bool() const  {…}
 
  const uint8_t* begin() const {
    return m_value;
  }
  const uint8_t* begin() const  {…}
 
  const uint8_t* end() const {
    return m_value + m_size;
  }
  const uint8_t* end() const  {…}
 
  size_t size() const {
    return m_size;
  }
  size_t size() const  {…}
 
  void encodeTo(Encoder& encoder) const {
    uint8_t* room = encoder.prependRoom(m_size);
    if (room != nullptr) {
      std::copy_n(m_value, m_size, room);
    }
  }
  void encodeTo(Encoder& encoder) const  {…}
 
  bool decodeFrom(const Decoder::Tlv& d) {
    m_value = d.value;
    m_size = d.length;
    return true;
  }
  bool decodeFrom(const Decoder::Tlv& d) {…}
 
  Decoder makeDecoder() const {
    return Decoder(m_value, m_size);
  }
  Decoder makeDecoder() const  {…}
 
  Value clone(Region& region) const {
    uint8_t* copyV = region.alloc(m_size);
    if (copyV == nullptr) {
      return Value();
    }
    std::copy(begin(), end(), copyV);
    return Value(copyV, m_size);
  }
  Value clone(Region& region) const  {…}
 
private:
  const uint8_t* m_value = nullptr;
  size_t m_size = 0;
};
class Value {…};
 
inline bool
operator==(const Value& lhs, const Value& rhs) {
  return lhs.size() == rhs.size() && std::equal(lhs.begin(), lhs.end(), rhs.begin());
}
operator==(const Value& lhs, const Value& rhs) {…}
 
NDNPH_DECLARE_NE(Value, inline)
 
} // namespace tlv
} // namespace ndnph
 
#endif // NDNPH_TLV_VALUE_HPP