v40_write_ROBFragment.h

Go to the documentation of this file.

//Dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 

 
#ifndef OFFLINE_EFORMAT_V40_WRITE_ROBFRAGMENT_H
#define OFFLINE_EFORMAT_V40_WRITE_ROBFRAGMENT_H
 
#include "eformat/write/node.h"
#include "eformat/Version.h"
#include "CxxUtils/checker_macros.h"
 
namespace offline_eformat {
 
  namespace v40_write {
 
    class FullEventFragment; //forward

    class ROBFragment
    {
    public:

      ROBFragment (uint32_t source_id,
           uint32_t run_no,
           uint32_t lvl1_id,
           uint32_t bc_id,
           uint32_t lvl1_type,
           uint32_t detev_type,
           uint32_t ndata,
           const uint32_t* data,
           uint32_t status_position);

      ROBFragment (uint32_t rob_source_id,
           uint32_t rod_source_id,
           uint32_t run_no,
           uint32_t lvl1_id,
           uint32_t bc_id,
           uint32_t lvl1_type,
           uint32_t detev_type,
           uint32_t ndata,
           const uint32_t* data,
           uint32_t status_position);

      ROBFragment ();

      ROBFragment (const ROBFragment& other);

      ROBFragment (const uint32_t* rod, uint32_t size_word);

      ROBFragment (const uint32_t* rob);

      virtual ~ROBFragment ();

      ROBFragment& operator= (const ROBFragment& other);

      void copy_header(const uint32_t* other);
      void copy_header(const ROBFragment& other);

      void status (uint32_t n, const uint32_t* status);

      inline uint32_t nstatus (void) const { return m_node[0].base[5]; }

      inline const uint32_t* status (void) const { return m_node[1].base; }

      inline void minor_version (uint16_t v)
      { m_node[0].base[3] &= 0xffff0000;
    m_node[0].base[3] |= v; }

      inline uint16_t minor_version (void) const 
      { return 0xffff & m_node[0].base[3]; }

      void rod_status (uint32_t n, const uint32_t* status);

      inline uint32_t rod_nstatus (void) const { return m_node[6].base[0]; }

      inline const uint32_t* rod_status (void) const { return m_node[4].base; }

      void status_position (uint32_t v);

      inline uint32_t status_position (void) const 
      { return m_node[6].base[2]; }

      inline void rod_minor_version (uint16_t v)
      { m_node[3].base[2] = eformat::DEFAULT_ROD_VERSION | v; }
      
      inline uint16_t rod_minor_version (void) const 
      { return 0xffff & m_node[3].base[2]; }

      void rod_data (uint32_t n, const uint32_t* data);

      inline uint32_t rod_ndata (void) const { return m_node[6].base[1]; }

      inline const uint32_t* rod_data (void) const { return m_node[5].base; }

      inline void source_id (uint32_t s) 
      { m_node[0].base[4] = m_node[3].base[3] = s; }

      inline void rod_source_id (uint32_t s) { m_node[3].base[3] = s; }

      inline void rob_source_id (uint32_t s) { m_node[0].base[4] = s; }

      inline uint32_t source_id (void) const { return m_node[0].base[4]; }

      inline uint32_t rob_source_id (void) const { return source_id(); }

      inline uint32_t rod_source_id (void) const { return m_node[3].base[3]; }

      void checksum_type (uint32_t s);

      inline uint32_t checksum_type (void) const { return m_node[2].base[0]; }
      
      inline void rod_run_no (uint32_t s) 
      { m_node[3].base[4] = (s & 0x7fffffff); }

      inline uint32_t rod_run_no (void) const 
      { return m_node[3].base[4]; }

      inline void rod_lvl1_id (uint32_t s) 
      { m_node[3].base[5] = s; }

      inline uint32_t rod_lvl1_id (void) const 
      { return m_node[3].base[5]; }

      inline void rod_bc_id (uint32_t s) 
      { m_node[3].base[6] = s; }

      inline uint32_t rod_bc_id (void) const 
      { return m_node[3].base[6]; }

      inline void rod_lvl1_type (uint32_t s) 
      { m_node[3].base[7] = s; }

      inline uint32_t rod_lvl1_type (void) const 
      { return m_node[3].base[7]; }

      inline void rod_detev_type (uint32_t s) 
      { m_node[3].base[8] = s; }

      inline uint32_t rod_detev_type (void) const 
      { return m_node[3].base[8]; }

      inline uint32_t meta_size_word (void) const
      { return rob_header_size_word() + rod_header_size_word() + 
               rod_trailer_size_word() + rod_nstatus() + 
               rob_trailer_size_word(); }

      inline uint32_t size_word (void) const
      { return meta_size_word() + rod_ndata(); }

      inline uint32_t rob_header_size_word (void) const 
      { return 7 + m_node[0].base[5]; }

      inline uint32_t rob_trailer_size_word (void) const 
      { return (checksum_type()?1:0); }

      inline uint32_t page_count (void) const 
      { return 7 + (checksum_type()?1:0); }
      
      inline uint32_t rod_page_count (void) const { return 4; }

      inline const uint32_t* rod_header (void) const 
      { return m_node[3].base; }

      inline uint32_t rod_header_size_word (void) const 
      { return m_node[3].size_word; }

      inline const uint32_t* rod_trailer (void) const 
      { return m_node[6].base; }

      inline uint32_t rod_trailer_size_word (void) const 
      { return m_node[6].size_word; }

      eformat::write::node_t* bind (void);

      const eformat::write::node_t* rod_bind (void);

      inline void parent (v40_write::FullEventFragment* ros)
      { m_parent = ros; }

      inline const v40_write::FullEventFragment* parent (void) const { return m_parent; }

      inline void next (ROBFragment* n) { m_next = n; }

      inline const ROBFragment* next (void) const { return m_next; }
      inline       ROBFragment* next (void)       { return m_next; }
 
    private: //to make the code simpler

      void initialize(void);
 
    private: //representation
 
      uint32_t m_header[7]; 
      uint32_t m_rod_header[9]; 
      uint32_t m_rod_trailer[3]; 
      uint32_t m_checksum; 
      eformat::write::node_t m_node[8]; 
      v40_write::FullEventFragment* m_parent; 
      v40_write::ROBFragment* m_next; 
 
    };
 
  }
 
}
 
#endif /* OFFLINE_EFORMAT_V40_WRITE_ROBFRAGMENT_H */