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