blob.hpp

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

#include <iostream>
#include "../common.hpp"
#include "../c/util/blob-types.h"
#include "../lite/util/blob-lite.hpp"

namespace ndn {

class Blob : public ptr_lib::shared_ptr<const std::vector<uint8_t> > {
public:
  Blob()
  {
  }

  Blob(const uint8_t* value, size_t valueLength)
  : ptr_lib::shared_ptr<const std::vector<uint8_t> >
      (value ? new std::vector<uint8_t>(value, value + valueLength) : 0)
  {
  }

  Blob(const std::vector<uint8_t> &value)
  : ptr_lib::shared_ptr<const std::vector<uint8_t> >(new std::vector<uint8_t>(value))
  {
  }

  Blob(const struct ndn_Blob& blobStruct)
  : ptr_lib::shared_ptr<const std::vector<uint8_t> >
      (blobStruct.value ?
        new std::vector<uint8_t>(blobStruct.value, blobStruct.value + blobStruct.length)
        : 0)
  {
  }

  Blob(const BlobLite& blobLite)
  : ptr_lib::shared_ptr<const std::vector<uint8_t> >
      (blobLite.isNull() ? 0
        : new std::vector<uint8_t>(blobLite.buf(), blobLite.buf() + blobLite.size()))
  {
  }

  Blob(const Blob& blob)
  : ptr_lib::shared_ptr<const std::vector<uint8_t> >(blob)
  {
  }

  Blob(const ptr_lib::shared_ptr<std::vector<uint8_t> > &value, bool copy)
  : ptr_lib::shared_ptr<const std::vector<uint8_t> >
     ((const ptr_lib::shared_ptr<const std::vector<uint8_t> > &)value)
  {
    if (copy)
      this->reset(new std::vector<uint8_t>(*value));
  }
  Blob(const ptr_lib::shared_ptr<const std::vector<uint8_t> > &value, bool copy)
  : ptr_lib::shared_ptr<const std::vector<uint8_t> >(value)
  {
    if (copy)
      this->reset(new std::vector<uint8_t>(*value));
  }

  DEPRECATED_IN_NDN_CPP Blob(const ptr_lib::shared_ptr<std::vector<uint8_t> > &value)
  : ptr_lib::shared_ptr<const std::vector<uint8_t> >((const ptr_lib::shared_ptr<const std::vector<uint8_t> > &)value)
  {
  }
  DEPRECATED_IN_NDN_CPP Blob(const ptr_lib::shared_ptr<const std::vector<uint8_t> > &value)
  : ptr_lib::shared_ptr<const std::vector<uint8_t> >(value)
  {
  }

  size_t
  size() const
  {
    if (*this)
      return (*this)->size();
    else
      return 0;
  }

  const uint8_t*
  buf() const
  {
    if (*this)
      return &(*this)->front();
    else
      return 0;
  }

  bool
  isNull() const { return !(*this); }

  std::string
  toHex() const { return (*this) ? ndn::toHex(**this) : std::string(); }

  std::string
  toRawStr() const
  {
    return (*this) ? std::string((const char*)(&(*this)->front()), (*this)->size())
                   : std::string();
  }

  bool
  equals(const Blob& other) const
  {
    if (isNull())
      return other.isNull();
    else if (other.isNull())
      return false;
    else
      // Use the vector equals operator.
      return (**this) == (*other);
  }

  void
  get(struct ndn_Blob& blobStruct) const
  {
    blobStruct.length = size();
    blobStruct.value = (size() > 0 ? buf() : 0);
  }

  operator const BlobLite() const
  {
    if (*this)
      return BlobLite(&(*this)->front(), (*this)->size());
    else
      return BlobLite();
  }
};

inline std::ostream&
operator << (std::ostream& os, const Blob& blob)
{
  for (size_t i = 0; i < blob.size(); ++i)
    os << blob.buf()[i];
  return os;
}

}

#endif