tlv-encoder.hpp

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
#ifndef NDN_TLV_ENCODER_HPP
#define NDN_TLV_ENCODER_HPP

#include <vector>
#include <string>
#include <stdexcept>
#include <ndn-cpp/common.hpp>
#include "../util/dynamic-uint8-vector.hpp"
#include "../c/encoding/tlv/tlv-encoder.h"

namespace ndn {

class TlvEncoder : public ndn_TlvEncoder {
public:
  TlvEncoder(size_t initialLength = 16)
  : output_(16)
  {
    ndn_TlvEncoder_initialize(this, &output_);
  }

  const ptr_lib::shared_ptr<std::vector<uint8_t> >&
  getOutput()
  {
    output_.get()->resize(offset);
    return output_.get();
  }

  void
  writeTypeAndLength(unsigned int type, size_t length)
  {
    ndn_Error error;
    if ((error = ndn_TlvEncoder_writeTypeAndLength(this, type, length)))
      throw std::runtime_error(ndn_getErrorString(error));
  }

  void
  writeNonNegativeInteger(uint64_t value)
  {
    ndn_Error error;
    if ((error = ndn_TlvEncoder_writeNonNegativeInteger(this, value)))
      throw std::runtime_error(ndn_getErrorString(error));
  }

  void
  writeBlobTlv(unsigned int type, struct ndn_Blob *value)
  {
    ndn_Error error;
    if ((error = ndn_TlvEncoder_writeBlobTlv(this, type, value)))
      throw std::runtime_error(ndn_getErrorString(error));
  }

  void
  writeRawStringTlv(unsigned int type, const std::string& value)
  {
    struct ndn_Blob valueBlob;
    ndn_Blob_initialize(&valueBlob, (const uint8_t*)&value[0], value.size());
    writeBlobTlv(type, &valueBlob);
  }

  void
  writeNonNegativeIntegerTlv(unsigned int type, uint64_t value)
  {
    ndn_Error error;
    if ((error = ndn_TlvEncoder_writeNonNegativeIntegerTlv(this, type, value)))
      throw std::runtime_error(ndn_getErrorString(error));
  }

  void
  writeNestedTlv
  (unsigned int type,
   ndn_Error (*writeValue)(const void *context, struct ndn_TlvEncoder* encoder),
   const void *context, bool omitZeroLength = false)
  {
    ndn_Error error;
    if ((error = ndn_TlvEncoder_writeNestedTlv
         (this, type, writeValue, context, omitZeroLength ? 1 : 0)))
      throw std::runtime_error(ndn_getErrorString(error));
  }

  void
  writeNestedTlv
  (unsigned int type, void (*writeValue)(const void *context, TlvEncoder& encoder),
   const void *context, bool omitZeroLength = false)
  {
    WriteValueWrapper(writeValue, context).writeNestedTlv
      (*this, type, omitZeroLength);
  }

private:
  /* An WriteValueWrapper holds the caller context so that it can be
   * passed to the caller's writeValue. See writeNestedTlv.
   */
  class WriteValueWrapper {
  public:
    WriteValueWrapper
      (void (*writeValue)(const void *context, TlvEncoder& encoder), const void *context)
      : writeValue_(writeValue), context_(context) {}

    void
    writeNestedTlv(TlvEncoder& encoder, unsigned int type, bool omitZeroLength)
    {
      encoder.writeNestedTlv(type, writeValueWrapper, this, omitZeroLength);
    }

  private:
    static ndn_Error
    writeValueWrapper(const void *context, struct ndn_TlvEncoder *encoder)
    {
      const WriteValueWrapper& wrapper = *(const WriteValueWrapper*)context;
      wrapper.writeValue_(wrapper.context_, (TlvEncoder&)*encoder);

      // wrapper.writeValue_ has thrown an exception if needed.
      return NDN_ERROR_success;
    }

    void (*writeValue_)(const void *context, TlvEncoder& encoder);
    const void *context_;
  };

  DynamicUInt8Vector output_;
};

}

#endif