/home/mhx/git/github/libmoost/include/moost/container/memory_mapped_dataset/section_writer_base.hpp

Go to the documentation of this file.

/* vim:set ts=3 sw=3 sts=3 et: */
#ifndef MOOST_CONTAINER_MEMORY_MAPPED_DATASET_SECTION_WRITER_BASE_HPP__
#define MOOST_CONTAINER_MEMORY_MAPPED_DATASET_SECTION_WRITER_BASE_HPP__

#include <string>
#include <vector>
#include <stdexcept>

#include <boost/type_traits/is_pod.hpp>
#include <boost/noncopyable.hpp>

#include "dataset.hpp"

namespace moost { namespace container {

class mmd_section_writer_base : public boost::noncopyable
{
public:
   mmd_section_writer_base(memory_mapped_dataset::writer& wr, const std::string& name, const std::string& type, size_t alignment)
      : m_name(name)
      , m_wr(wr)
      , m_committed(false)
   {
      wr.create_section(name, type, alignment);
   }

   virtual ~mmd_section_writer_base()
   {
      try
      {
         commit();
      }
      catch (...)
      {
      }
   }

   void commit()
   {
      if (!m_committed)
      {
         pre_commit();
         m_wr.commit_section(m_name);
         m_committed = true;
      }
   }

protected:
   void rollback()
   {
      m_wr.uncreate_section(m_name);
   }

   template <typename T>
   void setattr(const std::string& attr, const T& value)
   {
      m_wr.setattr(m_name, attr, value);
   }

   template <typename T>
   void write(const std::vector<T>& vec)
   {
      BOOST_STATIC_ASSERT_MSG(boost::is_pod<T>::value, "only POD types can be written to a dataset");
      write(reinterpret_cast<const char *>(&vec[0]), vec.size()*sizeof(T));
   }

   template <typename T>
   void write(const T& value)
   {
      BOOST_STATIC_ASSERT_MSG(boost::is_pod<T>::value, "only POD types can be written to a dataset");
      write(reinterpret_cast<const char *>(&value), sizeof(value));
   }

   void write(const std::string& value)
   {
      write(&value[0], value.size());
   }

   void write(const char *value, size_t size)
   {
      if (m_committed)
      {
         throw std::runtime_error("write access to committed section");
      }
      m_wr.write(m_name, value, size);
   }

   virtual void pre_commit()
   {
   }

private:
   const std::string m_name;
   memory_mapped_dataset::writer& m_wr;
   bool m_committed;
};

}}

#endif