buffer.hpp

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
/*
 * Copyright (c) 2013, Regents of the University of California
 *
 * BSD license, See the LICENSE file for more information
 *
 * Author: Alexander Afanasyev <[email protected]>
 */

#ifndef NDN_BUFFER_HPP
#define NDN_BUFFER_HPP

#include "../common.hpp"

namespace ndn {

class Buffer;
typedef ptr_lib::shared_ptr<const Buffer> ConstBufferPtr;
typedef ptr_lib::shared_ptr<Buffer> BufferPtr;

class Buffer : public std::vector<uint8_t>
{
public:
  Buffer()
  {
  }

  explicit
  Buffer(size_t size)
    : std::vector<uint8_t>(size, 0)
  {
  }

  Buffer(const void* buf, size_t length)
    : std::vector<uint8_t>(reinterpret_cast<const uint8_t*>(buf),
                           reinterpret_cast<const uint8_t*>(buf) + length)
  {
  }

  template <class InputIterator>
  Buffer(InputIterator first, InputIterator last)
    : std::vector<uint8_t>(first, last)
  {
  }

  uint8_t*
  get()
  {
    return &front();
  }

  uint8_t*
  buf()
  {
    return &front();
  }

  template<class T>
  T*
  get()
  {
    return reinterpret_cast<T*>(&front());
  }

  const uint8_t*
  buf() const
  {
    return &front();
  }

  const uint8_t*
  get() const
  {
    return &front();
  }

  template<class T>
  const T*
  get() const
  {
    return reinterpret_cast<const T*>(&front());
  }
};

namespace iostreams
{

class buffer_append_device
{
public:
  typedef char char_type;
  typedef boost::iostreams::sink_tag category;

  buffer_append_device(Buffer& container)
  : m_container(container)
  {
  }

  std::streamsize
  write(const char_type* s, std::streamsize n)
  {
    std::copy(s, s+n, std::back_inserter(m_container));
    return n;
  }

protected:
  Buffer& m_container;
};

} // iostreams

struct OBufferStream : public boost::iostreams::stream<iostreams::buffer_append_device>
{
  OBufferStream()
    : m_buffer(ptr_lib::make_shared<Buffer>())
    , m_device(*m_buffer)
  {
    open(m_device);
  }

  ptr_lib::shared_ptr<Buffer>
  buf()
  {
    flush();
    return m_buffer;
  }

private:
  BufferPtr m_buffer;
  iostreams::buffer_append_device m_device;
};


} // ndn

#endif // NDN_BUFFER_HPP