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