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