dynamic-uint8-vector.hpp

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

#include <vector>
#include <stdexcept>
#include <ndn-cpp/common.hpp>
#include "../c/util/dynamic-uint8-array.h"

namespace ndn {

class DynamicUInt8Vector : public ndn_DynamicUInt8Array {
public:
  DynamicUInt8Vector(size_t initialLength);

  void
  ensureLength(size_t length)
  {
    ndn_Error error;
    if ((error = ndn_DynamicUInt8Array_ensureLength(this, length)))
      throw std::runtime_error(ndn_getErrorString(error));
  }

  size_t
  copy(const uint8_t *value, size_t valueLength, size_t offset)
  {
    ndn_Error error;
    if ((error = ndn_DynamicUInt8Array_copy(this, value, valueLength, offset)))
      throw std::runtime_error(ndn_getErrorString(error));

    return offset + valueLength;
  }

  size_t
  copy(const std::vector<uint8_t>& value, size_t offset)
  {
    return copy(&value[0], value.size(), offset);
  }

  void
  ensureLengthFromBack(size_t length)
  {
    ndn_Error error;
    if ((error = ndn_DynamicUInt8Array_ensureLengthFromBack(this, length)))
      throw std::runtime_error(ndn_getErrorString(error));
  }

  void
  copyFromBack(const uint8_t *value, size_t valueLength, size_t offsetFromBack)
  {
    ndn_Error error;
    if ((error = ndn_DynamicUInt8Array_copyFromBack
         (this, value, valueLength, offsetFromBack)))
      throw std::runtime_error(ndn_getErrorString(error));
  }

  ptr_lib::shared_ptr<std::vector<uint8_t> >&
  get() { return vector_; }

  uint8_t&
  operator [] (size_t i) { return (*vector_)[i]; }

  const uint8_t&
  operator [] (size_t i) const { return (*vector_)[i]; }

private:
  static uint8_t*
  realloc(struct ndn_DynamicUInt8Array *self, uint8_t *array, size_t length);

  ptr_lib::shared_ptr<std::vector<uint8_t> > vector_;
};

}

#endif