TCDataProcessor.hpp

Go to the documentation of this file.

// *** this file is generated by oksdalgen, do not modify it ***
 
#ifndef _TCDataProcessor_0_dunedaq__appmodel_0_appmodel_H_
#define _TCDataProcessor_0_dunedaq__appmodel_0_appmodel_H_
 
#include <stdint.h>   // to define 64 bits types
#include <iostream>
#include <sstream>
#include <string>
#include <map>
#include <vector>
 
#include "conffwk/Configuration.hpp"
#include "conffwk/DalObject.hpp"
 
  // include files for classes used in inheritance hierarchy
 
#include "appmodel/DataProcessor.hpp"
 
  // forward declaration for classes used in relationships and algorithms
 
namespace dunedaq {
  namespace appmodel {
    class ROIGroupConf;
    class SourceIDConf;
    class TCReadoutMap;
    class TriggerBitword;
  }
}
 
 
namespace dunedaq {
  namespace appmodel {
 
    class TCDataProcessor : public dunedaq::appmodel::DataProcessor {
 
      friend class conffwk::Configuration;
      friend class conffwk::DalObject;
      friend class conffwk::DalFactory;
      friend class conffwk::DalRegistry;
 
      protected:
 
        TCDataProcessor(conffwk::DalRegistry& db, const conffwk::ConfigObject& obj) noexcept;
        virtual ~TCDataProcessor() noexcept;
        virtual void init(bool init_children);
 
      public:
 
        static const std::string& s_class_name;
 
 
        virtual void print(unsigned int offset, bool print_header, std::ostream& s) const;
 
 
        virtual std::vector<const dunedaq::conffwk::DalObject *> get(const std::string& name, bool upcast_unregistered = true) const;
 
 
      protected:
 
        bool get(const std::string& name, std::vector<const dunedaq::conffwk::DalObject *>& vec, bool upcast_unregistered, bool first_call) const;
 
 
      private:
 
        bool m_merge_overlapping_tcs;
        bool m_ignore_overlapping_tcs;
        bool m_td_out_of_timeout;
        uint32_t m_buffer_timeout;
        uint32_t m_td_readout_limit;
        std::vector<uint32_t> m_ignore_tc;
        std::vector<const dunedaq::appmodel::TriggerBitword*> m_trigger_bitwords;
        std::vector<const dunedaq::appmodel::ROIGroupConf*> m_roi_group_conf;
        std::vector<const dunedaq::appmodel::TCReadoutMap*> m_tc_readout_map;
        std::vector<const dunedaq::appmodel::SourceIDConf*> m_mandatory_links;
 
 
      public:
 
          // attribute names
 
        inline static const std::string s_merge_overlapping_tcs = "merge_overlapping_tcs";
        inline static const std::string s_ignore_overlapping_tcs = "ignore_overlapping_tcs";
        inline static const std::string s_td_out_of_timeout = "td_out_of_timeout";
        inline static const std::string s_buffer_timeout = "buffer_timeout";
        inline static const std::string s_td_readout_limit = "td_readout_limit";
        inline static const std::string s_ignore_tc = "ignore_tc";
 
        static const std::string& __get_merge_overlapping_tcs_str() noexcept { return s_merge_overlapping_tcs; }
        static const std::string& __get_ignore_overlapping_tcs_str() noexcept { return s_ignore_overlapping_tcs; }
        static const std::string& __get_td_out_of_timeout_str() noexcept { return s_td_out_of_timeout; }
        static const std::string& __get_buffer_timeout_str() noexcept { return s_buffer_timeout; }
        static const std::string& __get_td_readout_limit_str() noexcept { return s_td_readout_limit; }
        static const std::string& __get_ignore_tc_str() noexcept { return s_ignore_tc; }
 
 
        bool
        get_merge_overlapping_tcs() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_merge_overlapping_tcs;
          }
 
        void
        set_merge_overlapping_tcs(bool value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_merge_overlapping_tcs, value);
          }
 
 
        bool
        get_ignore_overlapping_tcs() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_ignore_overlapping_tcs;
          }
 
        void
        set_ignore_overlapping_tcs(bool value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_ignore_overlapping_tcs, value);
          }
 
 
        bool
        get_td_out_of_timeout() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_td_out_of_timeout;
          }
 
        void
        set_td_out_of_timeout(bool value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_td_out_of_timeout, value);
          }
 
 
        uint32_t
        get_buffer_timeout() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_buffer_timeout;
          }
 
        void
        set_buffer_timeout(uint32_t value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_buffer_timeout, value);
          }
 
 
        uint32_t
        get_td_readout_limit() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_td_readout_limit;
          }
 
        void
        set_td_readout_limit(uint32_t value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_td_readout_limit, value);
          }
 
 
        const std::vector<uint32_t>&
        get_ignore_tc() const
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            check_init();
            return m_ignore_tc;
          }
 
        void
        set_ignore_tc(const std::vector<uint32_t>& value)
          {
            std::lock_guard scoped_lock(m_mutex);
            check();
            clear();
            p_obj.set_by_val(s_ignore_tc, value);
          }
 
 
          // relationship names
 
        inline static const std::string s_trigger_bitwords = "trigger_bitwords";
        inline static const std::string s_roi_group_conf = "roi_group_conf";
        inline static const std::string s_tc_readout_map = "tc_readout_map";
        inline static const std::string s_mandatory_links = "mandatory_links";
 
        static const std::string& __get_trigger_bitwords_str() noexcept { return s_trigger_bitwords; }
        static const std::string& __get_roi_group_conf_str() noexcept { return s_roi_group_conf; }
        static const std::string& __get_tc_readout_map_str() noexcept { return s_tc_readout_map; }
        static const std::string& __get_mandatory_links_str() noexcept { return s_mandatory_links; }
 
 
        const std::vector<const dunedaq::appmodel::TriggerBitword*>&
        get_trigger_bitwords() const
        {
          std::lock_guard scoped_lock(m_mutex);
          check();
          check_init();
          return m_trigger_bitwords;
        }
 
 
        void
        set_trigger_bitwords(const std::vector<const dunedaq::appmodel::TriggerBitword*>& value);
 
        const std::vector<const dunedaq::appmodel::ROIGroupConf*>&
        get_roi_group_conf() const
        {
          std::lock_guard scoped_lock(m_mutex);
          check();
          check_init();
          return m_roi_group_conf;
        }
 
 
        void
        set_roi_group_conf(const std::vector<const dunedaq::appmodel::ROIGroupConf*>& value);
 
        const std::vector<const dunedaq::appmodel::TCReadoutMap*>&
        get_tc_readout_map() const
        {
          std::lock_guard scoped_lock(m_mutex);
          check();
          check_init();
          return m_tc_readout_map;
        }
 
 
        void
        set_tc_readout_map(const std::vector<const dunedaq::appmodel::TCReadoutMap*>& value);
 
        const std::vector<const dunedaq::appmodel::SourceIDConf*>&
        get_mandatory_links() const
        {
          std::lock_guard scoped_lock(m_mutex);
          check();
          check_init();
          return m_mandatory_links;
        }
 
 
        void
        set_mandatory_links(const std::vector<const dunedaq::appmodel::SourceIDConf*>& value);
 
    };
 
      // out stream operator
 
    inline std::ostream& operator<<(std::ostream& s, const TCDataProcessor& obj)
      {
        return obj.print_object(s);
      }
 
    typedef std::vector<const TCDataProcessor*>::const_iterator TCDataProcessorIterator;
 
  }
}
 
#endif