dump_file.hh

Go to the documentation of this file.

#ifndef DATAQUEUE_FRAMEFACTORY_DUMP_FILE_HH
#define DATAQUEUE_FRAMEFACTORY_DUMP_FILE_HH
 
#include <fstream>
#include <sstream>
#include <iomanip>
 
/**
 * \author cpellegrino
 */
 
class FilenameGenerator
{
  std::string m_prefix;
  std::string m_postfix;
  std::size_t m_file_no;
  unsigned int m_detector_id;
 
 public:
 
  FilenameGenerator(const std::string& prefix,
                    const std::string& postfix)
    :
    m_prefix(prefix),
    m_postfix(postfix),
    m_file_no(0)
  {}
 
  void generate()
  {
    ++m_file_no;
  }
 
  std::string name(std::size_t run_number, unsigned int detector_id) const
  {
    std::ostringstream oss;
    oss << m_prefix
        << "_D"
        << std::setfill('0') << std::setw(8)
        << detector_id
        << "_R"
        << std::setfill('0') << std::setw(8)
        << run_number
        << "_N"
        << std::setfill('0') << std::setw(8)
        << m_file_no
        << m_postfix;
 
    return oss.str();
  }
};
 
class DumpFile
{
  std::ofstream m_outfile;
  FilenameGenerator m_fg;
  std::size_t m_current_file_size;
  std::size_t const m_max_file_size;
 
 public:
 
  DumpFile(const FilenameGenerator& fg, std::size_t max_file_size)
    :
    m_fg(fg),
    m_current_file_size(0),
    m_max_file_size(max_file_size)
  {}
 
  ~DumpFile()
  {
    m_outfile.close();
  }
 
  bool write(const CLBDataGram* data, unsigned int detector_id)
  {
    if (m_outfile.is_open())
    {
      if (data->size() + m_current_file_size + sizeof(int) > m_max_file_size)
      {
        m_fg.generate();
        m_outfile.close();
 
        m_outfile.open(m_fg.name(data->getRunNumber(), detector_id).c_str());
        m_current_file_size = 0;
      }
    }
    else
    {
      m_outfile.open(m_fg.name(data->getRunNumber(), detector_id).c_str());
      m_current_file_size = 0;
    }
 
    if (!m_outfile.is_open())
    {
      return false;
    }
 
    unsigned int const packet_size = data->size();
    m_outfile.write(
        static_cast<const char*>(
            static_cast<const void*>(
                &packet_size)),
        sizeof(packet_size));
 
    if (m_outfile.good())
    {
      m_current_file_size += sizeof(packet_size);
      if (m_outfile.write(data->raw(), data->size()).good())
      {
        m_current_file_size += data->size();
        return true;
      }
      else
      {
        return false;
      }
    }
    return false;
  }
};
 
#endif // DATAQUEUE_FRAMEFACTORY_DUMP_FILE_HH