clb_datagram.hh

Go to the documentation of this file.

#ifndef __CLBDATAGRAM_HH
#define __CLBDATAGRAM_HH

#include <DataFormats/clb_common_header.hh>
#include <DataFormats/infoword.hh>
#include <datatypespec.hh>
#include <benchmark/time_tracking.hh>
#include <boost/atomic.hpp>
#include <cassert>

/**
 * \author cpellegrino
 */

class CLBDataGram : public benchmark::chronometrable
{

 public:

  static const size_t DGRAM_CAPACITY = 10000; // It should be at
                                              // least the size of a
                                              // jumbo frame payload
                                              // (9000)

 private:

  char m_block[DGRAM_CAPACITY];
  size_t m_size;

  CLBDataGram(const CLBDataGram&);
  CLBDataGram& operator =(const CLBDataGram&);

 public:

  static boost::atomic<unsigned int> n_obj;

  CLBDataGram()
    :
    m_size(0)
  {
    ++n_obj;
  }

  ~CLBDataGram()
  {
    --n_obj;
  }

  size_t size() const
  {
    return m_size;
  }

  void resize(size_t s)
  {
    assert(s <= DGRAM_CAPACITY);
    m_size = s;
  }

  void clear()
  {
    m_size = 0;
  }

  char* raw()
  {
    return m_block;
  }

  const char* raw() const
  {
    return m_block;
  }

  size_t capacity() const
  {
    return DGRAM_CAPACITY;
  }

  uint32_t getUDPSequenceNumber() const
  {
    return getCLBCommonHeader()->udpSequenceNumber();
  }

  uint32_t getRunNumber() const
  {
    return getCLBCommonHeader()->runNumber();
  }

  const CLBCommonHeader* getCLBCommonHeader() const
  {
    return static_cast<const CLBCommonHeader*>(
        static_cast<const void*>(m_block));
  }

  const char* getPayload() const
  {
    return m_block + sizeof(CLBCommonHeader);
  }

  bool isOptical() const
  {
    return is_optical(getCLBCommonHeader()->dataType());
  }

  bool isAcoustic() const
  {
    return is_acoustic(getCLBCommonHeader()->dataType());
  }

  bool hasInfoWord() const
  {
    return isAcoustic() && is_infoword(getPayload());
  }

  size_t getPayloadSize() const
  {
    return m_size <= sizeof(CLBCommonHeader) ?
        0 :
        (m_size - sizeof(CLBCommonHeader));
  }

  bool hasValidTimeStamp() const
  {
    return validTimeStamp(*getCLBCommonHeader());
  }

  bool isTrailer() const
  {
    return isOptical() && ::isTrailer(*getCLBCommonHeader());
  }
};
#endif