dqdumpfile.hh

Go to the documentation of this file.

#ifndef DQDUMPFILE_HH
#define DQDUMPFILE_HH
 
#include <fstream>
#include <vector>
 
#include <DataFormats/clb_common_header.hh>
 
/**
 * \author cpellegrino
 */
 
class Packet
{
  std::vector<char> m_data;
 
 public:
 
  Packet() {}
 
  Packet& operator =(const Packet& packet)
  {
    m_data = packet.m_data;
    return *this;
  }
 
  Packet(const Packet& packet)
    :
    m_data(packet.m_data)
  {}
 
  Packet(std::size_t size)
  {
    m_data.resize(size);
  }
 
  CLBCommonHeader const* CLBHeader() const
  {
    return static_cast<CLBCommonHeader const*>(
        static_cast<void const*>(
            &m_data.front()));
  }
 
  char const* payload() const
  {
    return &m_data.front() + sizeof(CLBCommonHeader);
  }
 
  std::size_t size() const
  {
    return m_data.size();
  }
 
  char* data()
  {
    return &m_data.front();
  }
 
  char const* data() const
  {
    return &m_data.front();
  }
};
 
class DumpFile
{
  std::ifstream m_stream;
  std::vector<std::size_t> m_pos;
 
  DumpFile(DumpFile const&);
  DumpFile& operator =(DumpFile const&);
 
 public:
 
  class iterator
  {
    DumpFile* m_file;
    std::size_t m_index;
 
   public:
 
    iterator()
      :
      m_file(0),
      m_index(0)
    {}
 
    iterator(DumpFile* x, std::size_t idx = 0)
      :
      m_file(x),
      m_index(idx)
    {}
 
    iterator(const iterator& mit)
      :
      m_file(mit.m_file),
      m_index(mit.m_index)
    {}
 
    iterator& operator++()
    {
      ++m_index;
      return *this;
    }
 
    iterator operator++(int)
    {
      iterator tmp(*this);
      operator++();
      return tmp;
    }
 
    iterator& operator--()
    {
      --m_index;
      return *this;
    }
 
    iterator operator--(int)
    {
      iterator tmp(*this);
      operator--();
      return tmp;
    }
 
    bool operator ==(const iterator& rhs)
    {
      return m_index == rhs.m_index && m_file == rhs.m_file;
    }
 
    bool operator !=(const iterator& rhs)
    {
      return !(*this == rhs);
    }
 
    Packet operator*()
    {
      return m_file->operator [](m_index);
    }
  };
 
  DumpFile(std::string const& filename)
    :
    m_stream(filename.c_str())
  {
    while (m_stream) {
      m_pos.push_back(m_stream.tellg());
      uint32_t pack_size;
      m_stream.read((char*) &pack_size, sizeof(pack_size));
      m_stream.ignore(pack_size);
    }
    m_pos.pop_back();
  }
 
  iterator begin()
  {
    return iterator(this, 0);
  }
 
  iterator end()
  {
    return iterator(this, m_pos.size());
  }
 
  Packet operator [](std::size_t n)
  {
    m_stream.clear();
    m_stream.seekg(m_pos[n]);
 
    uint32_t pack_size;
    m_stream.read((char*) &pack_size, sizeof(pack_size));
 
    Packet dg(pack_size);
    m_stream.read(dg.data(), pack_size);
    return dg;
  }
 
  std::size_t size() const
  {
    return m_pos.size();
  }
};
 
#endif // DQDUMPFILE_HH